Version bump and changelog for release (#9577)

When OCA token refresh fails with 400 invalid_grant or 401, legacy secrets
ocaAccessToken and ocaTokenSet (from older Cline versions) were left in VS
Code's secret storage. clearAuth() only cleared ocaApiKey and ocaRefreshToken,
causing every subsequent re-auth attempt to fail in a loop requiring manual
SQLite deletion to recover.

Fix:
- Add ocaAccessToken and ocaTokenSet to SecretKeys in state-keys.ts
- Update OcaAuthProvider.clearAuth() to clear all 4 OCA secrets

Fixes #9567

.agents/skills/create-pull-request/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: create-pull-request
-description: Create a GitHub pull request following project conventions. Use when the user asks to create a PR, submit changes for review, or open a pull request. Handles commit analysis, branch management, and PR creation using the gh CLI tool.
+description: Create a GitHub pull request following project conventions. Use when the user asks to create a PR, submit changes for review, or open a pull request. Handles commit analysis, branch management, PR template usage, and PR creation using the gh CLI tool.
 ---
 
 # Create Pull Request

.changeset/README.md

@@ -1,8 +0,0 @@
-# Changesets
-
-Hello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that works
-with multi-package repos, or single-package repos to help you version and publish your code. You can
-find the full documentation for it [in our repository](https://github.com/changesets/changesets)
-
-We have a quick list of common questions to get you started engaging with this project in
-[our documentation](https://github.com/changesets/changesets/blob/main/docs/common-questions.md)

.changeset/clear-rockets-happen.md

@@ -0,0 +1,5 @@
+---
+"cline": minor
+---
+
+Adds Messages API support to Oracle Code Assist, adding functionality for Claude models

.changeset/config.json

@@ -1,11 +0,0 @@
-{
-	"$schema": "https://unpkg.com/@changesets/config@3.0.5/schema.json",
-	"changelog": "@changesets/cli/changelog",
-	"commit": false,
-	"fixed": [],
-	"linked": [],
-	"access": "restricted",
-	"baseBranch": "main",
-	"updateInternalDependencies": "patch",
-	"ignore": []
-}

.changeset/cuddly-phones-count.md

@@ -0,0 +1,5 @@
+---
+"cline": patch
+---
+
+Add /q command to quit CLI

.changeset/early-beers-glow.md

@@ -0,0 +1,5 @@
+---
+"cline": patch
+---
+
+Add Additional Markdown Formatting in CLI

.changeset/fix-explain-changes-file-context-path.md

@@ -0,0 +1,16 @@
+---
+"cline": patch
+---
+
+fix: resolve "Could not find the file context" error in Explain Changes comment replies
+
+When clicking a line to start a discussion in the Explain Changes diff view, replies would
+intermittently fail with "Error: Could not find the file context". This happened because
+the reply handler and the `onCommentStart` callback were using a strict `absolutePath`-only
+match to look up files in `changedFiles`, while the VS Code comment controller may return
+paths in different formats (relative vs. absolute, different separators on Windows, etc.).
+
+Fixed by adding a `relativePath` fallback in both lookup sites, making them consistent with
+the already-correct logic in `streamAIExplanationComments`.
+
+Fixes #9382

.changeset/fix-oca-clear-stale-tokens.md

@@ -0,0 +1,18 @@
+---
+"cline": patch
+---
+
+fix: clear all OCA secrets on auth refresh failure to prevent re-auth loop
+
+When OCA (Oracle Code Assist) token refresh fails with 400 invalid_grant or 401,
+the stale secrets were not fully cleared from storage. The `clearAuth()` method
+only cleared `ocaApiKey` and `ocaRefreshToken`, leaving legacy secrets
+`ocaAccessToken` and `ocaTokenSet` (set by older Cline versions) in VS Code's
+secret storage. These stale secrets caused every subsequent re-auth attempt to
+fail in a loop, requiring manual SQLite deletion to recover.
+
+Fix:
+- Added `ocaAccessToken` and `ocaTokenSet` to `SecretKeys` in `state-keys.ts`
+- Updated `OcaAuthProvider.clearAuth()` to clear all 4 OCA secrets
+
+Fixes #9567

.changeset/neat-seals-guess.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Fix a streaming crash when a chunk has usage data but no `delta` by guarding reasoning field checks in provider handlers. Add regression tests for OpenRouter, Cline, Vercel AI Gateway, and Fireworks handlers to cover usage-only chunks.

.changeset/safe-yaml-schema.md

@@ -0,0 +1,5 @@
+---
+"cline": patch
+---
+
+Use JSON_SCHEMA for yaml.load to prevent unsafe deserialization from untrusted sources

.changeset/small-bugs-complain.md

@@ -0,0 +1,4 @@
+"claude-dev": patch
+---
+
+Add missing smoke evaluation npm scripts so documented commands like `npm run eval:smoke:run` work from the repository root.

.changeset/smoke-test-retries.md

@@ -0,0 +1,5 @@
+---
+"cline": patch
+---
+
+Add automatic retries (up to 3 attempts) for smoke test CI jobs to reduce flaky failures

.changeset/strong-dolls-beam.md

@@ -0,0 +1,5 @@
+---
+"cline": patch
+---
+
+add focus ring on action buttons

.changeset/tender-berries-search.md

@@ -0,0 +1,5 @@
+---
+"cline": patch
+---
+
+fix acp auth check so acp mode can be used with more providers

.changeset/wacky-ends-relax.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Update SambaNova Provider models list and add temperature for models

.changie.yaml

@@ -1,26 +0,0 @@
-changesDir: .changes
-unreleasedDir: unreleased
-headerPath: header.tpl.md
-changelogPath: CHANGELOG.md
-versionExt: md
-versionFormat: '## {{.Version}} - {{.Time.Format "2006-01-02"}}'
-kindFormat: "### {{.Kind}}"
-changeFormat: "* {{.Body}}"
-kinds:
-    - label: Added
-      auto: minor
-    - label: Changed
-      auto: major
-    - label: Deprecated
-      auto: minor
-    - label: Removed
-      auto: major
-    - label: Fixed
-      auto: patch
-    - label: Security
-      auto: patch
-newlines:
-    afterChangelogHeader: 1
-    beforeChangelogVersion: 1
-    endOfVersion: 1
-envPrefix: CHANGIE_

.clinerules/general.md

@@ -14,7 +14,7 @@ This file is the secret sauce for working effectively in this codebase. It captu
 
 ## Miscellaneous
 - This is a VS Code extension—check `package.json` for available scripts before trying to verify builds (e.g., `npm run compile`, not `npm run build`).
-- When creating PRs, if the change is user-facing and significant enough to warrant a changelog entry, run `npm run changeset` and create a patch changeset. Never create minor or major version bumps. Skip changesets for trivial fixes, internal refactors, or minor UI tweaks that users wouldn't notice.
+- When creating PRs, contributors should not create changelog-entry files. Maintainers handle release versioning and changelog curation during the release process.
 - When adding new feature flags, see this PR as a reference https://github.com/cline/cline/pull/7566
 - Additional instructions about making requests: @.clinerules/network.md
 

.clinerules/storage.md

@@ -0,0 +1,64 @@
+# Storage Architecture
+
+Global settings, secrets and workspace state are stored in **file-backed JSON stores** under `~/.cline/data/`. This is the shared storage layer used by VSCode, CLI, and JetBrains.
+
+## Key Abstractions
+
+### `StorageContext` (src/shared/storage/storage-context.ts)
+The entry point. Created via `createStorageContext()` and passed to `StateManager.initialize()`. Contains three `ClineFileStorage` instances:
+- `globalState` → `~/.cline/data/globalState.json`
+- `secrets` → `~/.cline/data/secrets.json` (mode 0o600)
+- `workspaceState` → `~/.cline/data/workspaces/<hash>/workspaceState.json`
+
+### `ClineFileStorage` (src/shared/storage/ClineFileStorage.ts)
+Synchronous JSON key-value store backed by a single file. Supports `get()`, `set()`, `setBatch()`, `delete()`. Writes are atomic (write-then-rename).
+
+### `StateManager` (src/core/storage/StateManager.ts)
+In-memory cache on top of `StorageContext`. All runtime reads hit the cache; writes update cache immediately and debounce-flush to disk.
+
+## ⚠️ Do NOT Use VSCode's ExtensionContext for Storage
+
+**Do not** read from or write to `context.globalState`, `context.workspaceState`, or `context.secrets` for persistent data. These are VSCode-specific and not available on CLI or JetBrains.
+
+Instead, use:
+```typescript
+// Reading state
+StateManager.get().getGlobalStateKey("myKey")
+StateManager.get().getSecretKey("mySecretKey")
+StateManager.get().getWorkspaceStateKey("myWsKey")
+
+// Writing state
+StateManager.get().setGlobalState("myKey", value)
+StateManager.get().setSecret("mySecretKey", value)
+StateManager.get().setWorkspaceState("myWsKey", value)
+```
+
+Remember that your data may be read by a different client than the one that wrote it. For example, a value written by Cline in JetBrains may be read by Cline CLI.
+
+## VSCode Migration (src/hosts/vscode/vscode-to-file-migration.ts)
+
+On VSCode startup, a migration copies data from VSCode's `ExtensionContext` storage into the file-backed stores. This runs in `src/common.ts` before `StateManager.initialize()`.
+
+- **Sentinel**: `__vscodeMigrationVersion` key in global state and workspace state — prevents re-migration.
+- **Merge strategy**: File store wins. Existing values are never overwritten.
+- **Safe downgrade**: VSCode storage is NOT cleared, so older extension versions still work.
+
+## Adding New Storage Keys
+
+1. Add to `src/shared/storage/state-keys.ts` (see existing patterns)
+2. Read/write via `StateManager` (NOT via `context.globalState`)
+3. If adding a secret, add to `SecretKeys` array in `state-keys.ts`
+
+## File Layout
+
+```
+~/.cline/
+  data/
+    globalState.json          # Global settings & state
+    secrets.json              # API keys (mode 0o600)
+    tasks/
+      taskHistory.json        # Task history (separate file)
+    workspaces/
+      <hash>/
+        workspaceState.json   # Per-workspace toggles
+```

.clinerules/workflows/address-pr-comments.md

@@ -19,7 +19,7 @@ Review and address all comments on the current branch's PR.
    - Inline comments: `gh api repos/{owner}/{repo}/pulls/{pr_number}/comments`
    - General comments: `gh pr view {pr_number} --json comments,reviews`
 
-4. Present a summary of all comments with your recommendation for each (apply, skip, or respond). Ignore bot noise (changeset-bot, CI status, etc.).
+4. Present a summary of all comments with your recommendation for each (apply, skip, or respond). Ignore bot noise (release automation, CI status, etc.).
 
 5. **Wait for my approval** before proceeding.
 

.clinerules/workflows/extension-release.md

@@ -1,549 +0,0 @@
-The goal of this workflow is to take a changeset for a release of Cline, an autonomous coding agent extension that plugs right into your IDE, and write the updated announcement component, and the updated changelog. 
-
-
-For reference, here are some examples of how we converted previous changesets to announcement components / changelogs. 
-
-
-- 3.14
-<changeset>
-This PR was opened by the Changesets release GitHub action. When you're ready to do a release, you can merge this and publish to npm yourself or setup this action to publish automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated.
-
-Releases
-claude-dev@3.14.0
-Minor Changes
-77c9863: create clinerules folder if its currently a file and creating new rule
-0ffb7dd: disabling shift hint for now & improving tooltip behavior
-79b76fd: Add support for custom model ID in AWS Bedrock provider, enabling use of Application Inference Profile.
-eb6e481: Full support for LaTeX rendering
-df37f29: Add support for custom API request timeout. Previously, timeouts were hardcoded to 30 seconds for providers like Ollama or 15 seconds for OpenRouter and Cline. Now users can set a custom timeout value in milliseconds through the settings interface.
-e4d26be: allow cursorrules and windsurfrules
-c5de50f: Fix Handle @withRetry() SyntaxError when running extension locally issue
-61d2f42: enabled pricing calculation for gemini and vertex + more robust caching & cache tracking for gemini & vertex
-aed152b: add truncation notice when truncating manually
-2fe2405: Migrate Cline Tools Section to new docs
-19cc8bc: Add a timeout setting for the terminal connection, allowing users to adjust this if they are having timeout issues
-03d4410: Added copy button to code blocks.
-c78fe23: addressed race condition in terminal command usage
-91e222f: add checkpoints after more messages
-14230e7: add newrule slash command
-1c7d33a: Add remote config with posthog allowing for disabling new features until they're reading, making for a better developer experience.
-4196c14: add cache ui for open router and cline provider
-d97424f: showing expanded task by default
-5294e78: Refactor to not pass a message for showing the MCP View from the servers modal
-70cc437: Fix Windows path issue: Correct handling of import.meta.url to avoid leading slash in pathname
-4b697d8: Migrate the addRemoteServer to protobus
-Patch Changes
-c63d9a1: updated drag and drop text to say "drop" instead of "drag"
-459adf0: Add markdown copy to chat
-74ec823: Minor UX improvement to drag and drop ux
-b0961f4: Remove linear pull request action
-e9ce384: searchCommits protobus migration
-5802b68: createRuleFile protobus migration
-df7f9fc: Add dependsOn to more blocks in the tasks.json
-41ae732: Fix for git commit mentions in repos with no git commits
-7e78445: Adding args to allow Cursor to open workspaces (for checkpoint testing/development)
-bdfda6f: feat(bedrock): Introduce Amazon Nova Premier
-65243ad: Introduce UI library for future UI development
-4565e06: checkIsImageURL migrated to protobus
-5a8e9d8: protobus migration for openImage
-deeda6e: Lowering Gemini cache TTL time
-db0b022: Adding UI to show openrouter balance next to provider
-4650ffa: deleteRuleFile protobus migration
-d4bd755: fix cost calculation
-</changeset>
-
-<changelog>
-## [3.14.0]
-
--   Add UI to show openrouter balance next to provider
--   Add support for custom model ID in AWS Bedrock provider, enabling use of Application Inference Profile (Thanks @clicube!)
--   Add more robust caching & cache tracking for gemini & vertex providers
--   Add support for LaTeX rendering
--   Add support for custom API request timeout. Timeouts were 15-30s, but can now be configured via settings for OpenRouter/Cline & Ollama (Thanks @WingsDrafterwork!)
--   Add truncation notice when truncating manually
--   Add a timeout setting for the terminal connection, allowing users to set a time to wait for terminal startup
--   Add copy button to code blocks
--   Add copy button to markdown blocks (Thanks @weshoke!)
--   Add checkpoints to more messages
--   Add slash command to create a new rules file (/newrule)
--   Add cache ui for open router and cline provider
--   Add Amazon Nova Premier model to Bedrock (Thanks @watany!)
--   Add support for cursorrules and windsurfrules
--   Add support for batch history deletion (Thanks @danix800!)
--   Improve Drag & Drop experience
--   Create clinerules folder creating new rule if it's needed
--   Enable pricing calculation for gemini and vertex providers
--   Refactor message handling to not show the MCP View of the server modal
--   Migrate the addRemoteServer to protobus (Thanks @DaveFres!)
--   Update task header to be expanded by default
--   Update Gemini cache TTL time to 15 minutes
--   Fix race condition in terminal command usage
--   Fix to correctly handle `import.meta.url`, avoiding leading slash in pathname for Windows (Thanks @DaveFres!)
--   Fix @withRetry() decoration syntax error when running extension locally (Thanks @DaveFres!)
--   Fix for git commit mentions in repos with no git commits
--   Fix cost calculation (Thanks @BarreiroT!)
-</changelog>
-
-
-<announcement-component>
-const Announcement = ({ version, hideAnnouncement }: AnnouncementProps) => {
-	const minorVersion = version.split(".").slice(0, 2).join(".") // 2.0.0 -> 2.0
-	return (
-		<div style={containerStyle}>
-			<VSCodeButton appearance="icon" onClick={hideAnnouncement} style={closeIconStyle}>
-				<span className="codicon codicon-close"></span>
-			</VSCodeButton>
-			<h3 style={h3TitleStyle}>
-				🎉{"  "}New in v{minorVersion}
-			</h3>
-			<ul style={ulStyle}>
-				<li>
-					<b>Gemini prompt caching:</b> Gemini and Vertex providers now support prompt caching and price tracking for
-					Gemini models.
-				</li>
-				<li>
-					<b>Copy Buttons:</b> Buttons were added to Markdown and Code blocks that allow you to copy their contents
-					easily.
-				</li>
-				<li>
-					<b>/newrule command:</b> New slash command to have cline write your .clinerules for you based on your
-					workflow.
-				</li>
-				<li>
-					<b>Drag and drop improvements:</b> Don't forget to hold shift while dragging files!
-				</li>
-				<li>Added more checkpoints across the task, allowing you to restore from more than just file changes.</li>
-				<li>Added support for rendering LaTeX in message responses. (Try asking Cline to show the quadratic formula)</li>
-			</ul>
-			<Accordion isCompact className="pl-0">
-				<AccordionItem
-					key="1"
-					aria-label="Previous Updates"
-					title="Previous Updates:"
-					classNames={{
-						trigger: "bg-transparent border-0 pl-0 pb-0 w-fit",
-						title: "font-bold text-(--vscode-foreground)",
-						indicator:
-							"text-(--vscode-foreground) mb-0.5 -rotate-180 data-[open=true]:-rotate-90 rtl:rotate-0 rtl:data-[open=true]:-rotate-90",
-					}}>
-					<ul style={ulStyle}>
-						<li>
-							<b>Global Cline Rules:</b> store multiple rules files in Documents/Cline/Rules to share between
-							projects.
-						</li>
-						<li>
-							<b>Cline Rules Popup:</b> New button in the chat area to view workspace and global cline rules files
-							to plug and play specific rules for the task
-						</li>
-						<li>
-							<b>Slash Commands:</b> Type <code>/</code> in chat to see the list of quick actions, like starting a
-							new task (more coming soon!)
-						</li>
-						<li>
-							<b>Edit Messages:</b> You can now edit a message you sent previously by clicking on it. Optionally
-							restore your project when the message was sent!
-						</li>
-					</ul>
-				</AccordionItem>
-			</Accordion>
-
-			{/*
-			// Leave this here for an example of how to structure the announcement
-			<ul style={{ margin: "0 0 8px", paddingLeft: "12px" }}>
-				 <li>
-					OpenRouter now supports prompt caching! They also have much higher rate limits than other providers,
-					so I recommend trying them out.
-					<br />
-					{!apiConfiguration?.openRouterApiKey && (
-						<VSCodeButtonLink
-							href={getOpenRouterAuthUrl(vscodeUriScheme)}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Get OpenRouter API Key
-						</VSCodeButtonLink>
-					)}
-					{apiConfiguration?.openRouterApiKey && apiConfiguration?.apiProvider !== "openrouter" && (
-						<VSCodeButton
-							onClick={() => {
-								vscode.postMessage({
-									type: "apiConfiguration",
-									apiConfiguration: { ...apiConfiguration, apiProvider: "openrouter" },
-								})
-							}}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Switch to OpenRouter
-						</VSCodeButton>
-					)}
-				</li>
-				<li>
-					<b>Edit Cline's changes before accepting!</b> When he creates or edits a file, you can modify his
-					changes directly in the right side of the diff view (+ hover over the 'Revert Block' arrow button in
-					the center to undo "<code>{"// rest of code here"}</code>" shenanigans)
-				</li>
-				<li>
-					New <code>search_files</code> tool that lets Cline perform regex searches in your project, letting
-					him refactor code, address TODOs and FIXMEs, remove dead code, and more!
-				</li>
-				<li>
-					When Cline runs commands, you can now type directly in the terminal (+ support for Python
-					environments)
-				</li>
-			</ul>*/}
-			<div style={hrStyle} />
-			<p style={linkContainerStyle}>
-				Join us on{" "}
-				<VSCodeLink style={linkStyle} href="https://x.com/cline">
-					X,
-				</VSCodeLink>{" "}
-				<VSCodeLink style={linkStyle} href="https://discord.gg/cline">
-					discord,
-				</VSCodeLink>{" "}
-				or{" "}
-				<VSCodeLink style={linkStyle} href="https://www.reddit.com/r/cline/">
-					r/cline
-				</VSCodeLink>
-				for more updates!
-			</p>
-		</div>
-	)
-}
-</announcement-component>
-
-- 3.13
-
-<changeset>
-Minor Changes
-2964388: Added copy button to MermaidBlock component
-75143a7: Add the ability to fetch from global cline rules files
-Patch Changes
-a0252e7: convert inline style to tailwind css of file SettingsView.tsx
-ab59bd9: Add stream options back to xai provider
-7276f50: Icons to indicate an action is occuring outside of the users workspace
-0b19ba6: update to NEW model
-</changeset>
-
-<changelog>
-## [3.13.0]
-
--   Add Cline rules popover under the chat field, allowing you to easily add, enable & disable workspace level or global rule files
--   Add new slash command menu letting you type “/“ to do quick actions like creating new tasks
--   Add ability to edit past messages, with options to restore your workspace back to that point
--   Allow sending a message when selecting an option provided by the question or plan tool
--   Add command to jump to Cline's chat input
--   Add support for OpenAI o3 & 4o-mini (Thanks @PeterDaveHello and @arafatkatze!)
--   Add baseURL option for Google Gemini provider (Thanks @owengo and @olivierhub!)
--   Add support for Azure's DeepSeek model. (Thanks @yt3trees!)
--   Add ability for models that support it to receive image responses from MCP servers (Thanks @rikaaa0928!)
--   Improve search and replace diff editing by making it more flexible with models that fail to follow structured output instructions. (Thanks @chi-cat!)
--   Add detection of Ctrl+C termination in terminal, improving output reading issues
--   Fix issue where some commands with large output would cause UI to freeze
--   Fix token usage tracking issues with vertex provider (Thanks @mzsima!)
--   Fix issue with xAI reasoning content not being parsed (Thanks @mrubens!)
-</changelog>
-
-<announcement-component>
-const Announcement = ({ version, hideAnnouncement }: AnnouncementProps) => {
-	const minorVersion = version.split(".").slice(0, 2).join(".") // 2.0.0 -> 2.0
-	return (
-		<div style={containerStyle}>
-			<VSCodeButton appearance="icon" onClick={hideAnnouncement} style={closeIconStyle}>
-				<span className="codicon codicon-close"></span>
-			</VSCodeButton>
-			<h3 style={h3TitleStyle}>
-				🎉{"  "}New in v{minorVersion}
-			</h3>
-			<ul style={ulStyle}>
-				<li>
-					<b>Global Cline Rules:</b> store multiple rules files in Documents/Cline/Rules to share between projects.
-				</li>
-				<li>
-					<b>Cline Rules Popup:</b> New button in the chat area to view workspace and global cline rules files to plug
-					and play specific rules for the task
-				</li>
-				<li>
-					<b>Slash Commands:</b> Type <code>/</code> in chat to see the list of quick actions, like starting a new task
-					(more coming soon!)
-				</li>
-				<li>
-					<b>Edit Messages:</b> You can now edit a message you sent previously by clicking on it. Optionally restore
-					your project when the message was sent!
-				</li>
-			</ul>
-			<h4 style={{ margin: "5px 0 5px" }}>Previous Updates:</h4>
-			<ul style={ulStyle}>
-				<li>
-					<b>Model Favorites:</b> You can now mark your favorite models when using Cline & OpenRouter providers for
-					quick access!
-				</li>
-				<li>
-					<b>Faster Diff Editing:</b> Improved animation performance for large files, plus a new indicator in chat
-					showing the number of edits Cline makes.
-				</li>
-				<li>
-					<b>New Auto-Approve Options:</b> Turn off Cline's ability to read and edit files outside your workspace.
-				</li>
-			</ul>
-			{/*
-			// Leave this here for an example of how to structure the announcement
-			<ul style={{ margin: "0 0 8px", paddingLeft: "12px" }}>
-				 <li>
-					OpenRouter now supports prompt caching! They also have much higher rate limits than other providers,
-					so I recommend trying them out.
-					<br />
-					{!apiConfiguration?.openRouterApiKey && (
-						<VSCodeButtonLink
-							href={getOpenRouterAuthUrl(vscodeUriScheme)}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Get OpenRouter API Key
-						</VSCodeButtonLink>
-					)}
-					{apiConfiguration?.openRouterApiKey && apiConfiguration?.apiProvider !== "openrouter" && (
-						<VSCodeButton
-							onClick={() => {
-								vscode.postMessage({
-									type: "apiConfiguration",
-									apiConfiguration: { ...apiConfiguration, apiProvider: "openrouter" },
-								})
-							}}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Switch to OpenRouter
-						</VSCodeButton>
-					)}
-				</li>
-				<li>
-					<b>Edit Cline's changes before accepting!</b> When he creates or edits a file, you can modify his
-					changes directly in the right side of the diff view (+ hover over the 'Revert Block' arrow button in
-					the center to undo "<code>{"// rest of code here"}</code>" shenanigans)
-				</li>
-				<li>
-					New <code>search_files</code> tool that lets Cline perform regex searches in your project, letting
-					him refactor code, address TODOs and FIXMEs, remove dead code, and more!
-				</li>
-				<li>
-					When Cline runs commands, you can now type directly in the terminal (+ support for Python
-					environments)
-				</li>
-			</ul>*/}
-			<div style={hrStyle} />
-			<p style={linkContainerStyle}>
-				Join us on{" "}
-				<VSCodeLink style={linkStyle} href="https://x.com/cline">
-					X,
-				</VSCodeLink>{" "}
-				<VSCodeLink style={linkStyle} href="https://discord.gg/cline">
-					discord,
-				</VSCodeLink>{" "}
-				or{" "}
-				<VSCodeLink style={linkStyle} href="https://www.reddit.com/r/cline/">
-					r/cline
-				</VSCodeLink>
-				for more updates!
-			</p>
-		</div>
-	)
-}
-</announcement-component>
-
-
-We have a changeset PR that automatically generated as new unreleased PRs are merged into main, the PR is always called "Changeset version bump" and the author is github-actions. 
-
-The Changeset PR description looks something like this:
-
-<changeset-pr-description>
-This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and publish to npm yourself or [setup this action to publish automatically](https://github.com/changesets/action#with-publishing). If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated.
-
-
-# Releases
-## claude-dev@3.16.0
-
-### Minor Changes
-
--   c6e8b04: Recent task list is now collapsible, allowing users to hide their recent tasks (e.g. when sharing their screen).
--   aabe4ae: Add detection for new users to display special components
--   6c18d51: adds global endpoint for vertex ai users
--   080ed7c: Add Tailwind CSS IntelliSense to the the recommended extensions list
--   5147e28: new workflow feature
-
-### Patch Changes
-
--   c0b3c69: fix eternal loading states when the last message is a checkpoint
--   570ece3: selectImages protos migration
--   8d8452e: askResponse protobus migration
--   cd1ff2a: Finishing the migration of Vscode Advanced settings to Settings Webview
-</changeset-pr-description>
-
-The changeset pr is ALWAYS on the following branch: `changeset-release/main`.
-
-I have the `gh` command line tool set up and authenticated, so you have everything you need.
-
-The first step is to get the full diff from the changeset PR to look at the changes that were automatically made to the `CHANGELOG.md` file. By default it will automatically add a new section to the changelog.md file with the new version. The problem with the automatically generated section is that it just takes the text that the developers threw into their changeset files for each corresponding PR, and they can be pretty vague and bad. Additionally there's some stuff that is totally irrelevant for the end user, like minor refactoring changes. So I manually typically go in and update this section to be a proper changelog that will show up in our patchnotes. You can look at how the rest of the file is done because those are all good examples of us updating this to use good language for the end user. We usually put new features up top (and the most exciting flagship features at the very top), and then bug fixes/improvements at the bottom. Having some basic organization to the ordering of the bullet points by content is nice. But use common sense. 
-
-To handle this process effectively, do the following:
-
-For each of the automatically generated bullet points in the Changelog.md, you should
-1. Take the commit hash at the start of the bullet point, and use the `gh` command line tool find the PR that it was associated with. 
-2. Use the `gh` command to get the PR title/description/discussion to understand the context surrounding the PR.
-3. Use the `gh` command line tool to get the full PR diff to fully understand the changes made in the code.
-4. Synthesize that knowledge to determine (a) whether or not this change is relevant to end users and (b) what the text & ordering of the line should be.  
-5. Update the `CHANGELOG.md` accordingly 
-
-Do this for every single item in the list from the autogenerated bullet points. We want to be diligent and have a full understanding of every feature so we can make the best changelog ever!
-
-Here are some principles for good changelogs from keepchangelog.com, a handy guide:
-
-<keepachangelog-pinciples-for-good-changelogs>
-### Guiding Principles
-- Changelogs are for humans, not machines.
-- There should be an entry for every single version.
-- The same types of changes should be grouped.
-- The latest version comes first.
-
-### Bullet points in the changelog should follow these principles:
-- Types of changes
-- Added for new features.
-- Changed for changes in existing functionality.
-- Deprecated for soon-to-be removed features.
-- Removed for now removed features.
-- Fixed for any bug fixes.
-- Security in case of vulnerabilities.
-</keepachangelog-pinciples-for-good-changelogs>
-
-Lastly, when developers make a PR, they typically make a changeset. And they have 3 options when making the changeset:
-
-1. Patch
-2. Minor
-3. Major
-
-Sometimes they label something as minor when really it should just be a patch. Or vice versa. Because of this, the automatic version bump may be incorrect. So when starting out this workflow, you should use the <ask_followup_question> tool to confirm with me whether or not this should be a patch bump (show the old version number and what the proposed new version number would be) or a minor bump. Part of the release process is making sure the version in package.json that is automatically changed actually corresponds with what we decided the bump should actually be based on the features. ALL these modifications happen in the `changeset-release/main` branch btw. 
-
-<important_note>
-Before doing any of this, make sure you check out the `changeset-release/main` and pull the most recent up to date changes. Then perform all this work in that branch. 
-
-New announcement banners should ONLY be made for minor version bumps or higher. That's another reason why double checking if the changelog warrants the bump is important.
-
-Also, SUPER important: For any external contributors that aren't part of the cline github organization, we always want to add a (Thanks @username!) at the end of the changelog to attribute them properly. We're an open source project and it's ethical to do this.
-</important_note>
-
-Once the changelog looks good, and the version number looks good, we gotta double check that the version number in the changelog has the brackets around it. And as a final step, double check the package.json version number matches the latest number in the changelog. And as the ultimate final step we run `npm run install:all` to make sure the package version number permiates through the lock file. 
-
-
-<detailed_sequence_of_steps>
-# Cline Release Process - Detailed Sequence of Steps
-
-## Before Starting
-1. First, examine the changeset PR without checking it out:
-   ```bash
-   gh pr view changeset-release/main
-   ```
-
-2. View the PR diff to see the auto-generated CHANGELOG.md changes:
-   ```bash
-   gh pr diff changeset-release/main > changeset-diff.txt
-   cat changeset-diff.txt | grep -A 50 "CHANGELOG.md"
-   ```
-
-## Initial Setup
-3. Once you're ready to start, checkout and update the changeset release branch:
-   ```bash
-   git checkout changeset-release/main
-   git pull origin changeset-release/main
-   ```
-
-## Analyzing Each Change
-4. For each commit hash in the auto-generated changelog entries:
-
-   a. Find the PR number associated with a commit hash:
-      ```bash
-      gh pr list --search "<commit-hash>" --state merged
-      ```
-   
-   b. Get PR details for better context:
-      ```bash
-      gh pr view <PR-number>
-      ```
-   
-   c. Check if the contributor is external to determine if attribution is needed:
-      ```bash
-      # Extract username from PR
-      USERNAME=$(gh pr view <PR-number> --json author --jq .author.login)
-      
-      # Check if user is a member of the Cline organization
-	  # this command is a bit finnicky, but it 100% works. 
-	  # if you see a `Error executing command: The command ran successfully, but we couldn't capture its output. Please proceed accordingly.` error, just retry it until you actually get the output
-	  # don't make any assumptions, just retry the command to actually get the output and determine if they're external or not.
-	  # no output means they are an external contributor, otherwise if there is output they are an internal contributor (part of our github org)
-      gh api "orgs/cline/members" --jq "map(.login)" | grep -i "pashpashpash"
-      ```
-   
-   d. View the full PR diff to understand code changes:
-      ```bash
-      gh pr diff <PR-number> > pr-diff-<PR-number>.txt
-      cat pr-diff-<PR-number>.txt
-      ```
-
-## Updating the Changelog
-5. Based on PR analysis, update the CHANGELOG.md with user-friendly descriptions:
-   - Use the `<replace_in_file>` tool to edit the CHANGELOG.md file
-   - Group by feature type (Added, Changed, Fixed)
-   - Put most exciting features at the top
-   - Move bug fixes and small improvements to the bottom
-   - Use clear, end-user focused language
-   - For external contributors, add attribution at the end of the relevant entry: `(Thanks @username!)`
-
-## Version Number Verification
-6. Confirm the version bump is appropriate:
-   - Check package.json to verify the auto-generated version number:
-     ```bash
-     cat package.json | grep "\"version\""
-     ```
-   - If the feature set doesn't warrant a minor bump, use the `<replace_in_file>` tool to modify package.json
-
-7. Ensure the version in CHANGELOG.md has brackets around it:
-   ```
-   ## [3.16.0]
-   ```
-
-## Creating the Announcement (for minor/major versions only)
-8. If this is a minor version bump, create/update the announcement component:
-   - Use the `<replace_in_file>` tool to edit the src/views/components/announcement.tsx file
-   - Update the highlights based on key features
-   - Move previous version highlights to the "Previous Updates" section
-   - Use the previous announcement components as reference for structure
-
-## Finalizing the Release
-9. Update dependencies with the new version number:
-   ```bash
-   npm run install:all
-   ```
-
-10. Commit your changes:
-    ```bash
-    git add CHANGELOG.md package.json package-lock.json src/views/components/announcement.tsx
-    git commit -m "Update CHANGELOG.md and announcement for version 3.16.0"
-    ```
-
-11. Push your changes to the changeset branch:
-    ```bash
-    git push origin changeset-release/main
-    ```
-
-12. Check that your changes pushed successfully:
-    ```bash
-    git status
-    ```
-</detailed_sequence_of_steps>

.clinerules/workflows/hotfix-release.md

@@ -89,16 +89,9 @@ On the main branch, create a commit that updates:
 
 2. **package.json** - Update the version field to the new version
 
-3. **Delete changesets** for the commits being included in the hotfix. This prevents the changeset bot from including duplicate entries in the next regular release.
+3. No changelog-entry file cleanup is needed. Contributors do not create changelog-entry files in this repo.
 
-   Find and delete the changeset files associated with the selected commits:
-   ```bash
-   ls .changeset/
-   ```
-
-   Each changeset file in `.changeset/` corresponds to a PR. Read them to identify which ones belong to the commits you're hotfixing, then delete those files.
-
-**Skip running `npm run install:all`** - the automation handles outdated lockfiles.
+**Skip running `npm run install:all`** - release automation handles lockfile consistency as needed.
 
 Commit with message format: `v{VERSION} Release Notes (hotfix)`
 
@@ -107,7 +100,7 @@ In the commit body, mention:
 - List the cherry-picked commits that will be included
 
 ```bash
-git add CHANGELOG.md package.json .changeset/
+git add CHANGELOG.md package.json
 git commit -m "v3.40.1 Release Notes (hotfix)
 
 Hotfix release including:

.clinerules/workflows/pr-review.md

@@ -347,8 +347,6 @@ A few notes:
 So until the settings page is update, and this is added to settings in a way that's clean and doesn't confuse new users, I don't think we can merge this. Please bear with us.
 </request_changes_comment>
 <request_changes_comment>
-Also, don't forget to add a changeset since this fixes a user-facing bug.
-
 The architectural change is solid - moving the focus logic to the command handlers makes sense. Just don't want to introduce subtle timing issues by removing those timeouts.
 </request_changes_comment>
 </example_comments_that_i_have_written_before>

.clinerules/workflows/release.md

@@ -1,232 +1,64 @@
 # Release
 
-Prepare and publish a release from the open changeset PR.
+Prepare and publish a release directly from `main`.
 
 ## Overview
 
 This workflow helps you:
-1. Find and checkout the open changeset PR
-2. Clean up the changelog (fix version format, wordsmith entries)
-3. Push changes back to the PR branch
-4. Merge with proper commit message format
-5. Tag and push the release (after verifying the commit)
-6. Trigger the publish workflow
-7. Update GitHub release notes
-8. Provide final summary with Slack announcement
+1. Select/confirm the target version
+2. Curate `CHANGELOG.md` entries manually for end users
+3. Ensure `package.json` version matches the changelog
+4. Create and push a release commit + tag
+5. Trigger publish workflow
+6. Update GitHub release notes and share a summary
 
-## Step 1: Find the Changeset PR
+## Process
 
-Look for the open changeset PR:
-
-```bash
-gh pr list --search "Changeset version bump" --state open --json number,title,headRefName,url
-```
-
-If no PR is found, inform the user there's no changeset PR ready. They may need to:
-- Merge PRs with changesets to main first
-- Manually trigger the Changeset Converter workflow at: https://github.com/cline/cline/actions/workflows/changeset-converter.yml
-
-## Step 2: Gather PR Information
-
-Get the PR details:
-
-```bash
-PR_NUMBER=<number from step 1>
-gh pr view $PR_NUMBER --json body,files,headRefName
-```
-
-Checkout the PR branch:
-
-```bash
-git fetch origin changeset-release/main
-git checkout changeset-release/main
-```
-
-If the branch has diverged from remote, reset to the remote version:
-
-```bash
-git reset --hard origin/changeset-release/main
-```
-
-## Step 3: Analyze the Changes
-
-Read the current CHANGELOG.md to see what the automation generated:
-
-```bash
-head -50 CHANGELOG.md
-```
-
-Get the version from package.json:
-
-```bash
-cat package.json | grep '"version"'
-```
-
-**Present to the user:**
-- The version number that will be released
-- The raw changelog entries from the changeset PR
-- Whether this is a patch, minor, or major release
-
-## Step 4: Clean Up the Changelog
-
-The changelog needs these fixes:
-
-1. **Add brackets to version number**: Change `## 3.44.1` to `## [3.44.1]`
-
-2. **No category headers**: Don't use `### Added`, `### Fixed`, etc. Just a flat list of bullet points.
-
-3. **Order entries from most important to least important**:
-   - Lead with major new features or significant fixes users care about
-   - End with minor fixes or internal changes
-
-4. **Write user-friendly descriptions**:
-   - This is for end users, not developers—explain what changed in plain language
-   - Remove commit hashes from the beginning of lines (the automation adds these)
-   - Look at the actual commit diffs (`git show <hash>`) and PRs to understand what changed
-   - Write colorful descriptions that explain the value and impact, not just technical details
-   - Consolidate related changes into single entries when appropriate
-
-**Ask the user** to review the proposed changelog changes before applying them. Show them:
-- Current (raw) changelog section
-- Proposed (cleaned) changelog section
-
-Once approved, apply the changes to CHANGELOG.md.
-
-## Step 5: Commit and Push Changes
-
-After making changelog edits:
-
-```bash
-git add CHANGELOG.md
-git commit -m "Clean up changelog formatting"
-git push origin changeset-release/main
-```
-
-## Step 6: Merge the PR
-
-**Ask the user to confirm** they're ready to merge.
-
-Merge the PR with the proper commit message format:
-
-```bash
-VERSION=<version from package.json>
-gh pr merge $PR_NUMBER --squash --subject "v${VERSION} Release Notes" --body ""
-```
-
-**If merge is blocked by branch protection:**
-- Users with admin privileges can add the `--admin` flag to bypass
-- Users without admin privileges need to get the PR approved through normal review first before merging
-
-## Step 7: Tag the Release
-
-After the merge completes, checkout main and pull:
+### 1) Sync and determine version
 
 ```bash
 git checkout main
 git pull origin main
+cat package.json | grep '"version"'
 ```
 
-**IMPORTANT: Verify the latest commit is the release commit before tagging:**
+Confirm the release version with the maintainer (patch/minor/major).
+
+### 2) Curate changelog and version
+
+- Edit `CHANGELOG.md` for the target version using human-friendly release notes.
+- Ensure version headers use bracket format, e.g. `## [3.66.1]`.
+- Update `package.json` version to the same value.
+
+### 3) Commit and tag
 
 ```bash
-git log -1 --oneline
+git add CHANGELOG.md package.json package-lock.json
+git commit -m "v<version> Release Notes"
+git push origin main
+git tag v<version>
+git push origin v<version>
 ```
 
-Confirm the commit message matches `v{VERSION} Release Notes` (e.g., `v3.44.1 Release Notes`). Do NOT blindly tag HEAD without verification.
+### 4) Trigger publish workflow
 
-Once verified, tag and push:
+Tell the maintainer to run:
+https://github.com/cline/cline/actions/workflows/publish.yml
+
+Use `v<version>` as the release tag.
+
+### 5) Update GitHub release notes
+
+After publish completes:
 
 ```bash
-VERSION=<version>
-git tag v${VERSION}
-git push origin v${VERSION}
+gh release view v<version> --json body --jq '.body'
+gh release edit v<version> --notes "<final curated release notes>"
 ```
 
-## Step 8: Trigger Publish Workflow
+### 6) Final summary
 
-**Copy the tag to clipboard** so the user can easily paste it into the GitHub Actions workflow:
-
-```bash
-echo -n "v{VERSION}" | pbcopy
-```
-
-**Tell the user to trigger the publish workflow:**
-1. Go to: https://github.com/cline/cline/actions/workflows/publish.yml
-2. Select **"release"** for release-type
-3. Paste **`v{VERSION}`** as the tag (already in clipboard)
-
-**Wait for the user** to confirm the publish workflow has completed before proceeding.
-
-## Step 9: Update GitHub Release Notes
-
-Once the user confirms the publish workflow is done, fetch the auto-generated release content:
-
-```bash
-VERSION=<version>
-gh release view v${VERSION} --json body --jq '.body'
-```
-
-The auto-generated release has:
-- `## What's Changed` - PR list (we'll replace this with our changelog)
-- `## New Contributors` - First-time contributors (keep this if present)
-- `**Full Changelog**` - Comparison link (keep this)
-
-Build the new release body:
-1. Start with `## What's Changed` header
-2. Add our changelog content (from CHANGELOG.md for this version)
-3. Keep the `## New Contributors` section if it exists
-4. Keep the `**Full Changelog**` link
-
-Update the release:
-
-```bash
-gh release edit v${VERSION} --notes "<new body content>"
-```
-
-Verify the release was updated:
-
-```bash
-gh release view v${VERSION}
-```
-
-## Step 10: Final Summary
-
-**Copy a Slack announcement message to clipboard** (include the full changelog, not just highlights):
-
-```bash
-echo "VS Code v{VERSION} Released
-
-- Changelog entry 1
-- Changelog entry 2
-- Changelog entry 3" | pbcopy
-```
-
-**Present a final summary:**
-- Version released: v{VERSION}
-- PR merged: #{PR_NUMBER}
-- Tag pushed: v{VERSION}
-- Release: https://github.com/cline/cline/releases/tag/v{VERSION}
-- Slack message copied to clipboard
-
-**Final reminder:**
-Post the Slack message to announce the release
-
-## Handling Edge Cases
-
-### No changesets found
-If the changeset PR body shows no changes, inform the user they need to merge PRs with changesets first.
-
-### Merge conflicts
-If there are conflicts on the changeset branch, help the user resolve them:
-```bash
-git fetch origin main
-git rebase origin/main
-# resolve conflicts
-git push origin changeset-release/main --force-with-lease
-```
-
-### User wants to add more changes
-If the user wants to include additional PRs before releasing:
-1. Ask them to merge those PRs to main first
-2. The changeset automation will update the PR automatically
-3. Re-run this workflow after the PR is updated
+Provide:
+- Released version/tag
+- Link to release page
+- Summary of top end-user changes

.codex/environments/environment.toml

@@ -32,3 +32,18 @@ rm node_modules
 rm webview-ui/node_modules
 npm run install:all
 '''
+
+[[actions]]
+name = "pull main"
+icon = "tool"
+command = '''
+git fetch origin main                                                                                                                                                             
+                                                                                                                                                                                
+if ! git merge-base --is-ancestor main origin/main; then                                                                                                                          
+  echo "Local main has commits not on origin/main. Aborting..."                                                                                                                     
+  exit 1                                                                                                                                                                          
+fi
+
+git update-ref refs/heads/main refs/remotes/origin/main
+echo "main updated to $(git rev-parse --short main)"
+'''

.github/pull_request_template.md

@@ -60,7 +60,6 @@ We're not looking for exhaustive documentation - just evidence that you've thoug
 
 -   [ ] Changes are limited to a single feature, bugfix or chore (split larger changes into separate PRs)
 -   [ ] Tests are passing (`npm test`) and code is formatted and linted (`npm run format && npm run lint`)
--   [ ] I have created a changeset using `npm run changeset` (required for user-facing changes)
 -   [ ] I have reviewed [contributor guidelines](https://github.com/cline/cline/blob/main/CONTRIBUTING.md)
 
 ### Screenshots

.github/scripts/overwrite_changeset_changelog.py

@@ -1,79 +0,0 @@
-"""
-This script updates a specific version's release notes section in CHANGELOG.md with new content
-or reformats existing content.
-
-The script:
-1. Takes a version number, changelog path, and optionally new content as input from environment variables
-2. Finds the section in the changelog for the specified version
-3. Either:
-   a) Replaces the content with new content if provided, or
-   b) Reformats existing content by:
-      - Removing the first two lines of the changeset format
-      - Ensuring version numbers are wrapped in square brackets
-4. Writes the updated changelog back to the file
-
-Environment Variables:
-    CHANGELOG_PATH: Path to the changelog file (defaults to 'CHANGELOG.md')
-    VERSION: The version number to update/format
-    PREV_VERSION: The previous version number (used to locate section boundaries)
-    NEW_CONTENT: Optional new content to insert for this version
-"""
-
-#!/usr/bin/env python3
-
-import os
-
-CHANGELOG_PATH = os.environ.get("CHANGELOG_PATH", "CHANGELOG.md")
-VERSION = os.environ['VERSION']
-PREV_VERSION = os.environ.get("PREV_VERSION", "")
-NEW_CONTENT = os.environ.get("NEW_CONTENT", "")
-
-def overwrite_changelog_section(changelog_text: str, new_content: str):
-    # Find the section for the specified version
-    version_pattern = f"## {VERSION}\n"
-    unformmatted_prev_version_pattern = f"## {PREV_VERSION}\n"
-    prev_version_pattern = f"## [{PREV_VERSION}]\n"
-    print(f"latest version: {VERSION}")
-    print(f"prev_version: {PREV_VERSION}")
-
-    notes_start_index = changelog_text.find(version_pattern) + len(version_pattern)
-    notes_end_index = changelog_text.find(prev_version_pattern, notes_start_index) if PREV_VERSION and (prev_version_pattern in changelog_text or unformmatted_prev_version_pattern in changelog_text) else len(changelog_text)
-
-    if new_content:
-        return changelog_text[:notes_start_index] + f"{new_content}\n" + changelog_text[notes_end_index:]
-    else:
-        changeset_lines = changelog_text[notes_start_index:notes_end_index].split("\n")
-        filtered_lines = []
-        for line in changeset_lines:
-            # If the previous line is a changeset format
-            if len(filtered_lines) > 1 and filtered_lines[-1].startswith("### "):
-                # Remove the last two lines from the filted_lines
-                filtered_lines.pop()
-                filtered_lines.pop()
-            else:
-                filtered_lines.append(line.strip())
-
-        # Prepend a new line to the first line of filtered_lines
-        if filtered_lines:
-            filtered_lines[0] = "\n" + filtered_lines[0]
-
-        # Print filted_lines wiht a "\n" at the end of each line
-        for line in filtered_lines:
-            print(line.strip())
-
-        parsed_lines = "\n".join(line for line in filtered_lines)
-        updated_changelog = changelog_text[:notes_start_index] + parsed_lines + changelog_text[notes_end_index:]
-        return updated_changelog
-
-with open(CHANGELOG_PATH, 'r') as f:
-    changelog_content = f.read()
-
-new_changelog = overwrite_changelog_section(changelog_content, NEW_CONTENT)
-# print("----------------------------------------------------------------------------------")
-# print(new_changelog)
-# print("----------------------------------------------------------------------------------")
-# Write back to CHANGELOG.md
-with open(CHANGELOG_PATH, 'w') as f:
-    f.write(new_changelog)
-
-print(f"{CHANGELOG_PATH} updated successfully!")

.github/workflows/changeset-converter.yml

@@ -1,113 +0,0 @@
-name: Changeset Converter
-run-name: Changeset Conversion
-
-on:
-    workflow_dispatch:
-    pull_request:
-        types: [closed]
-
-env:
-    REPO_PATH: ${{ github.repository }}
-    GIT_REF: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || 'main' }}
-    NODE_VERSION: 20.18.1
-
-jobs:
-    # Job 1: Create version bump PR when changesets are merged to main
-    changeset-pr-version-bump:
-        if: |
-            github.event_name == 'workflow_dispatch' ||
-            (
-                github.event_name == 'pull_request' &&
-                github.event.pull_request.merged == true &&
-                github.event.pull_request.base.ref == 'main' &&
-                github.actor != 'github-actions'
-            )
-        runs-on: ubuntu-latest
-        permissions:
-            contents: write
-            pull-requests: write
-        steps:
-            - name: Check user for team affiliation
-              id: team_check
-              if: github.event_name == 'workflow_dispatch'
-              uses: morfien101/actions-authorized-user@4a3cfbf0bcb3cafe4a71710a278920c5d94bb38b
-              with:
-                  username: ${{ github.actor }}
-                  org: ${{ github.repository_owner }}
-                  team: "deployer"
-                  github_token: ${{ secrets.GITHUB_TOKEN }}
-
-            - name: Check if user is authorized
-              if: github.event_name == 'workflow_dispatch'
-              run: |
-                  if [ "${{ steps.team_check.outputs.authorized }}" != "true" ]; then
-                      echo "User is not authorized to run this workflow."
-                      exit 1
-                  fi
-
-            - name: Git Checkout
-              uses: actions/checkout@v4
-              with:
-                  fetch-depth: 0
-                  ref: ${{ env.GIT_REF }}
-
-            - name: Setup Node.js
-              uses: actions/setup-node@v4
-              with:
-                  node-version: ${{ env.NODE_VERSION }}
-                  cache: "npm"
-
-            - name: Install Dependencies
-              run: npm ci
-
-            # Check if there are any new changesets to process
-            - name: Check for changesets
-              id: check-changesets
-              run: |
-                  NEW_CHANGESETS=$(find .changeset -name "*.md" ! -name "README.md" | wc -l | tr -d ' ')
-                  echo "Changesets diff with previous version: $NEW_CHANGESETS"
-                  echo "new_changesets=$NEW_CHANGESETS" >> $GITHUB_OUTPUT
-
-            # Create version bump PR using changesets/action if there are new changesets
-            - name: Create Changeset Pull Request
-              if: steps.check-changesets.outputs.new_changesets != '0'
-              uses: changesets/action@v1
-              with:
-                  commit: "changeset version bump"
-                  title: "Changeset version bump"
-                  version: npm run version-packages # This performs the changeset version bump
-              env:
-                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-            # Get current and previous versions to edit changelog entry
-            - name: Get version
-              id: get_version
-              run: |
-                  VERSION=$(git show HEAD:package.json | jq -r '.version')
-                  echo "version=$VERSION" >> $GITHUB_OUTPUT
-                  PREV_VERSION=$(git show origin/main:package.json | jq -r '.version')
-                  echo "prev_version=$PREV_VERSION" >> $GITHUB_OUTPUT
-                  echo "version=$VERSION"
-                  echo "prev_version=$PREV_VERSION"
-
-            # Update CHANGELOG.md with proper format
-            - name: Update Changelog Format
-              env:
-                  VERSION: ${{ steps.get_version.outputs.version }}
-                  PREV_VERSION: ${{ steps.get_version.outputs.prev_version }}
-              run: python .github/scripts/overwrite_changeset_changelog.py
-
-            # Commit and push changelog updates
-            - name: Push Changelog updates to Pull Request
-              run: |
-                  git config user.name "github-actions"
-                  git config user.email github-actions@github.com
-                  echo "Running git add and commit..."
-                  git add CHANGELOG.md
-                  git commit -m "Updating CHANGELOG.md format"
-                  git status
-                  echo "--------------------------------------------------------------------------------"
-                  echo "Pushing to remote..."
-                  echo "--------------------------------------------------------------------------------"
-                  CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
-                  git push origin $CURRENT_BRANCH

.github/workflows/cline-evals-regression.yml

@@ -0,0 +1,85 @@
+name: Smoke Tests
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'src/core/**'
+      - 'src/shared/**'
+      - 'proto/**'
+      - 'evals/**'
+      - '.github/workflows/cline-evals-regression.yml'
+  pull_request:
+    paths:
+      - 'src/core/**'
+      - 'src/shared/**'
+      - 'proto/**'
+      - 'evals/**'
+      - '.github/workflows/cline-evals-regression.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: smoke-tests-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  smoke-tests:
+    name: Smoke Tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build and install CLI
+        run: |
+          npm run protos
+          cd cli && npm install && npm run build && npm link
+          echo "$(npm config get prefix)/bin" >> $GITHUB_PATH
+
+      - name: Verify CLI
+        run: cline --version
+
+      - name: Run smoke tests
+        env:
+          CLINE_API_KEY: ${{ secrets.CLINE_API_KEY }}
+        run: |
+          cline auth -p cline -k "$CLINE_API_KEY" -m "anthropic/claude-sonnet-4.5"
+          max_attempts=3
+          for attempt in $(seq 1 $max_attempts); do
+            echo "::group::Attempt $attempt of $max_attempts"
+            if npx tsx evals/smoke-tests/run-smoke-tests.ts --trials 1 --parallel; then
+              echo "::endgroup::"
+              echo "Smoke tests passed on attempt $attempt"
+              exit 0
+            fi
+            echo "::endgroup::"
+            if [ $attempt -lt $max_attempts ]; then
+              echo "::warning::Smoke tests failed on attempt $attempt, retrying..."
+              sleep 10
+            fi
+          done
+          echo "::error::Smoke tests failed after $max_attempts attempts"
+          exit 1
+
+      - name: Generate summary
+        if: always()
+        run: cat evals/smoke-tests/results/latest/summary.md >> $GITHUB_STEP_SUMMARY
+
+      - name: Upload results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: smoke-test-results-${{ github.run_id }}
+          path: evals/smoke-tests/results/latest/
+          retention-days: 30

.github/workflows/publish-cli-trusted.yaml

@@ -39,6 +39,7 @@ jobs:
         !endsWith(github.actor, '[bot]')
       )
     uses: ./.github/workflows/npm-main.yaml
+    secrets: inherit
     with:
       confirm_publish: ${{ github.event.inputs.confirm_publish }}
 
@@ -49,5 +50,6 @@ jobs:
         (github.event_name == 'workflow_dispatch' && github.event.inputs.publish_target == 'nightly')
       )
     uses: ./.github/workflows/npm-nightly.yaml
+    secrets: inherit
     with:
       force_publish: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.force_nightly_publish == 'true' }}

.github/workflows/publish-nightly.yml

@@ -36,7 +36,9 @@ jobs:
             - name: Setup Node.js
               uses: actions/setup-node@v4
               with:
-                  node-version: "lts/*"
+                  # Keep publish environment aligned with test workflow/tooling lockfile expectations.
+                  # Newer LTS (Node 24 / npm 11) can make `npm list` fail with ELSPROBLEMS during vsce packaging.
+                  node-version: 22
 
             - name: Install root dependencies
               run: npm ci --include=optional

.github/workflows/publish.yml

@@ -42,7 +42,7 @@ jobs:
             - name: Setup Node.js
               uses: actions/setup-node@v4
               with:
-                  node-version: "lts/*"
+                  node-version: 22
 
             - name: Install root dependencies
               run: npm install --include=optional

.gitignore

@@ -48,3 +48,6 @@ test-results
 .secrets
 
 *.tsbuildinfo
+
+# Smoke test results (generated)
+evals/smoke-tests/results/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "evals/cline-bench"]
+	path = evals/cline-bench
+	url = https://github.com/cline/cline-bench.git

.vscode/launch.json

@@ -16,7 +16,8 @@
 				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
 				"--disable-extension",
 				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
-				"${workspaceFolder}"
+				"${workspaceFolder}",
+				"--disable-extensions"
 			],
 			"outFiles": [
 				"${workspaceFolder}/dist/**/*.js"

.vscodeignore

@@ -35,11 +35,9 @@ cli/**
 eslint-rules/
 old_docs/
 evals/
-.changie.yaml
 .codespellrc
 .mocharc.json
 buf.yaml
-.changeset/
 .clinerules/
 
 # Ignore all webview-ui files except the build directory (https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/frameworks/hello-world-react-cra/.vscodeignore)

CHANGELOG.md

@@ -1,5 +1,115 @@
 # Changelog
 
+## [3.68.0]
+
+### Added
+
+- Add dynamic Cline provider model fetching from Cline endpoint
+- Add additional Markdown formatting in CLI
+- Add focus indicator on action buttons in extension
+
+### Fixed
+
+- Clear all OCA secrets on auth refresh failure to prevent re-auth loops
+- Resolve "Could not find the file context" error in Explain Changes
+- Use `JSON_SCHEMA` for `yaml.load` to prevent unsafe deserialization
+- Fetch model info from API in CLI headless auth for Cline and Vercel providers
+- Generate commit message from staged changes only when staging exists
+- Update stale `maxTokens` values for Claude 3.7+ models across Anthropic, Bedrock, Vertex, and SAP AI Core
+- Use `model.info.maxTokens` for OpenRouter instead of hardcoded `8192`
+
+### Changed
+
+- Increase timeout for a flaky test to reduce short-term test instability
+
+## [3.67.1]
+
+### Added
+
+- Added Cline SDK API interface for programmatic access to Cline features and tools, enabling integration into custom applications.
+- Added Codex 5.3 model support
+
+### Fixed
+
+- Fix OpenAI Codex by setting `store` to `false`
+- Use `isLocatedInPath()` instead of string matching for path containment checks
+
+## [3.67.0]
+
+### Added
+
+- Add support for skills and optional modelId in subagent configuration
+- Add AgentConfigLoader for file-based agent configs
+- Add Responses API support for OpenAI native provider
+- Preconnect websocket to reduce response latency
+- Fetch featured models from backend with local fallback
+- Add /q command to quit CLI
+- Add MCP enterprise configuration details
+- Pull Cline's recommended models from internal endpoint
+- Add dynamic flag to adjust banner cache duration
+
+### Fixed
+
+- Fix reasoning delta crash on usage-only stream chunks
+- Fix OpenAI tool ID transformation restricted to native provider only
+- Fix auth check for ACP mode
+- Fix CLI yolo mode to not persist yolo setting to disk
+- Fix inline focus-chain slider within its feature row
+- Fix Gemini 3.1 Pro compatibility
+- Fix Cline auth with ACP flag
+
+### Changed
+
+- Move PR skill to .agents/skills
+- SambaNova provider: update models list
+- Remove changeset-converter GitHub Action and npm run changeset
+
+## [3.66.0]
+
+### Added
+
+- Gemini-3.1 Pro Preview
+
+
+## [3.65.0]
+
+### Added
+
+- Add /skills slash command to CLI for viewing and managing installed skills
+
+### Fixed
+
+- Fix aggressive context compaction caused by accidental clicks on the context window progress bar silently setting a very low auto-condense threshold
+- Fix infinite retry loop when write_to_file fails with missing content parameter.
+- Fixed default claude model
+
+## [3.64.0]
+
+### Added
+- Added sonnet 4.6
+
+
+## [3.63.0]
+
+### Added
+
+- added zai GLM 5 Free promo
+
+### Fixed
+
+- Restore reasoning trace visibility in chat and improve the thinking row UX so reasoning is visible, then collapsible after completion.
+
+## [3.62.0]
+
+### Fixed
+
+- Banners now display immediately when opening the extension instead of requiring user interaction first
+- Resolved 17 security vulnerabilities including high-severity DoS issues in dependencies (body-parser, axios, qs, tar, and others)
+
+## [3.61.0]
+
+- UI/UX fixes with minimax model family
+
 ## [3.60.0]
 
 - Fixes for Minimax model family
@@ -7,11 +117,12 @@
 ## [3.59.0]
 
 - Added Minimax 2.5 Free Promo
-- Fixed Response chaining for OpenAI's Responses API 
+- Fixed Response chaining for OpenAI's Responses API
 
 ## [3.58.0]
 
 ### Added
+
 - Subagent: replace legacy subagents with the native `use_subagents` tool
 - Bundle `endpoints.json` support so packaged distributions can ship required endpoints out-of-the-box
 - Amazon Bedrock: support parallel tool calling
@@ -22,6 +133,7 @@
 - ZAI/GLM: add GLM-5
 
 ### Fixed
+
 - CLI: handle stdin redirection correctly in CI/headless environments
 - CLI: preserve OAuth callback paths during auth redirects
 - VS Code Web: generate auth callback URLs via `vscode.env.asExternalUri` (OAuth callback reliability)
@@ -33,6 +145,7 @@
 - CI: increase Windows E2E test timeout to reduce flakiness
 
 ### Changed
+
 - Settings/model UX: move "reasoning effort" into model configuration and expose it in settings
 - CLI provider selection: limit provider list to those remotely configured
 - UI: consolidate ViewHeader component/styling across views
@@ -50,7 +163,7 @@
 ### Added
 
 - Cline CLI 2.0 now available. Install with `npm install -g cline`
-- Anthopic Opus 4.6 
+- Anthopic Opus 4.6
 - Minimax-2.1 and Kimi-k2.5 now available for free for a limited time promo
 - Codex-5.3 through ChatGPT subscription
 
@@ -70,23 +183,23 @@
 
 ### Added
 
-- __CLI authentication:__ Added Vercel AI Gateway and Cline API key provider support for headless CI/automation workflows
-- __New model:__ Added Kimi-K2.5 model to Moonshot provider (262K context, image support, prompt caching)
-- __Prompt variant:__ Added Trinity Large prompt variant for improved tool-calling support
-- __OpenTelemetry:__ Added support for custom headers on metrics and logs endpoints
-- __Social links:__ Added community icons (X, Discord, GitHub, Reddit, LinkedIn) to the What's New modal
+- **CLI authentication:** Added Vercel AI Gateway and Cline API key provider support for headless CI/automation workflows
+- **New model:** Added Kimi-K2.5 model to Moonshot provider (262K context, image support, prompt caching)
+- **Prompt variant:** Added Trinity Large prompt variant for improved tool-calling support
+- **OpenTelemetry:** Added support for custom headers on metrics and logs endpoints
+- **Social links:** Added community icons (X, Discord, GitHub, Reddit, LinkedIn) to the What's New modal
 
 ### Fixed
 
-- __LiteLLM:__ Fixed thinking configuration not appearing for reasoning-capable models
-- __OpenTelemetry:__ Fixed endpoint path handling (no longer incorrectly appends `/v1/logs` or `/v1/metrics`) and ensured logs are sent regardless of VSCode telemetry settings
-- __CLI auth:__ Fixed `cline auth` displaying incorrect provider information after configuration
+- **LiteLLM:** Fixed thinking configuration not appearing for reasoning-capable models
+- **OpenTelemetry:** Fixed endpoint path handling (no longer incorrectly appends `/v1/logs` or `/v1/metrics`) and ensured logs are sent regardless of VSCode telemetry settings
+- **CLI auth:** Fixed `cline auth` displaying incorrect provider information after configuration
 
 ### Changed
 
-- __Hooks:__ Hook scripts now run from the workspace repository root instead of filesystem root
-- __Default settings:__ Enabled multi-root workspaces, parallel tool calling, and skills by default; disabled strict plan mode by default
-- __Settings UI:__ Refreshed feature settings section with collapsible design
+- **Hooks:** Hook scripts now run from the workspace repository root instead of filesystem root
+- **Default settings:** Enabled multi-root workspaces, parallel tool calling, and skills by default; disabled strict plan mode by default
+- **Settings UI:** Refreshed feature settings section with collapsible design
 
 ## [3.55.0]
 

CONTRIBUTING.md

@@ -57,25 +57,11 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 
 ### Creating a Pull Request
 
-1. Before creating a PR, generate a changeset entry:
-    ```bash
-    npm run changeset
-    ```
-   This will prompt you for:
-   - Type of change (major, minor, patch)
-     - `major` → breaking changes (1.0.0 → 2.0.0)
-     - `minor` → new features (1.0.0 → 1.1.0)
-     - `patch` → bug fixes (1.0.0 → 1.0.1)
-   - Description of your changes
+1. Commit your changes.
 
-2. Commit your changes and the generated `.changeset` file
-
-3. Push your branch and create a PR on GitHub. Our CI will:
+2. Push your branch and create a PR on GitHub. Our CI will:
    - Run tests and checks
-   - Changesetbot will create a comment showing the version impact
-   - When merged to main, changesetbot will create a Version Packages PR
-   - When the Version Packages PR is merged, a new release will be published
-4. Testing
+3. Testing
     - Run `npm run test` to run tests locally. 
     - Before submitting PR, run `npm run format:fix` to format your code
 
@@ -192,15 +178,10 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
       - Temporary workspaces with test fixtures
       - Video recording for failed tests
 
-4. **Version Management with Changesets**
+4. **Versioning & Changelog Notes**
 
-    - Create a changeset for any user-facing changes using `npm run changeset`
-    - Choose the appropriate version bump:
-        - `major` for breaking changes (1.0.0 → 2.0.0)
-        - `minor` for new features (1.0.0 → 1.1.0)
-        - `patch` for bug fixes (1.0.0 → 1.0.1)
-    - Write clear, descriptive changeset messages that explain the impact
-    - Documentation-only changes don't require changesets
+    - Contributors do not need to create changelog-entry files as part of PRs.
+    - Maintainers handle release versioning and changelog curation during the release process.
 
 5. **Commit Guidelines**
 

SECURITY.md

@@ -0,0 +1,27 @@
+# Security Policy
+
+## Supported Versions
+
+We actively patch only the most recent minor release of Cline. Older versions receive fixes at our discretion.
+
+## Reporting a Vulnerability
+
+We appreciate your efforts to responsibly disclose your findings and will make every effort to acknowledge your contributions.
+
+To report a security issue, please use the GitHub Security Advisory ["Report a Vulnerability"](https://github.com/cline/cline/security/advisories/new) tab.
+
+The team will send a response indicating the next steps in handling your report. After the initial reply, the security team will keep you informed of the progress towards a fix and full announcement, and may ask for additional information or guidance.
+
+When reporting, please include:
+
+- A short summary of the issue
+- Steps to reproduce or a proof of concept
+- Any logs, stack traces, or screenshots that might help us understand the problem
+
+We acknowledge reports within 48 hours and aim to release a fix or mitigation within 30 days. While we work on a resolution, please keep the details private.
+
+## Escalation
+
+If you do not receive an acknowledgement of your report within 5 business days, you may send an email to security@cline.bot.
+
+Thank you for helping us keep Cline users safe.

cli/CHANGELOG.md

@@ -1,8 +1,74 @@
 # cline
 
+## [2.5.1]
+
+### Added
+
+- Expanded CLI markdown rendering support (headings, lists, blockquotes, fenced code blocks, links, and nested lists).
+
+### Fixed
+
+- Fixed CLI headless auth provider model metadata loading for Cline and Vercel AI Gateway by fetching model info from API with cache fallback.
+- Increased flaky CLI import test timeout on Windows CI to reduce intermittent test failures.
+
+## [2.5.0]
+
+### Added
+
+- Added Cline SDK API interface for programmatic access to Cline features and tools, enabling integration into custom applications.
+- Added Codex 5.3 model support
+
+### Fixed
+
+- Fix OpenAI Codex by setting `store` to `false`
+- Use `isLocatedInPath()` instead of string matching for path containment checks
+
+## [2.4.3]
+
+### Added
+
+- Add /q command to quit CLI
+- Fetch featured models from backend with local fallback
+
+### Fixed
+
+- Fix auth check for ACP mode
+- Fix Cline auth with ACP flag
+- Fix yolo mode to not persist yolo setting to disk
+
+## [2.4.2]
+
+### Added
+
+- Gemini-3.1 Pro Preview
+
+### Patch Changes
+
+- VSCode uses shared files for global, workspace and secret state.
+
+## [2.4.1]
+
+### Fixed
+
+- Fix infinite retry loop when write_to_file fails with missing content parameter. Provides progressive guidance to the model, escalating from suggestions to hard stops, with context window awareness to break the loop.
+
+## [2.4.0]
+
+### Added
+
+- Adding Anthropic Sonnet 4.6
+- Allows users to enter custom aws region when selecting bedrock as a provider in CLI
+- Keep reasoning rows visible when low-stakes tool groups start immediately after reasoning.
+- Restore reasoning trace visibility in chat and improve the thinking row UX so streamed reasoning is visible, then collapsible after completion.
+
+### Fixed
+
+- Banners now display immediately when opening the extension instead of requiring user interaction first
+- Resolved 17 security vulnerabilities including high-severity DoS issues in dependencies (body-parser, axios, qs, tar, and others)
+
 ## [2.2.2]
 
--  Allows users to enter custom aws region when selecting bedrock as a provider
+- Allows users to enter custom aws region when selecting bedrock as a provider
 - Prevent Parent Container Scrolling In Dropdowns
 
 ## [2.2.1]

cli/README.md

@@ -45,7 +45,7 @@ cline
 
 ### Use any API and Model
 
-Cline supports API providers like ChatGPT, Anthropic, OpenAI, Google Gemini, AWS Bedrock, Azure, GCP Vertex, Cerebras and Groq. You can also configure any OpenAI compatible API, or use a local model through LM Studio/Ollama. If you're using a Cline Account, you'll always have access to the newest models as soon as they're available.
+Cline supports API providers like ChatGPT, Anthropic, OpenAI, Google Gemini, AWS Bedrock, Azure, GCP Vertex, Cerebras, Groq, and Moonshot. You can also configure any OpenAI compatible API, or use a local model through LM Studio/Ollama. If you're using a Cline Account, you'll always have access to the newest models as soon as they're available.
 
 <!-- Transparent pixel to create line break after floating image -->
 
@@ -79,4 +79,3 @@ Get the same Cline experience with enterprise-grade controls: SSO (SAML/OIDC), g
 ## License
 
 [Apache 2.0 © 2026 Cline Bot Inc.](./LICENSE)
-

cli/esbuild.mts

@@ -208,8 +208,8 @@ if (production) {
 	buildEnvVars["process.env.IS_DEV"] = "false"
 }
 
-const config: esbuild.BuildOptions = {
-	entryPoints: [path.join(__dirname, "src", "index.ts")],
+// Shared build options
+const sharedOptions: Partial<esbuild.BuildOptions> = {
 	bundle: true,
 	minify: production,
 	sourcemap: !production,
@@ -221,7 +221,6 @@ const config: esbuild.BuildOptions = {
 	sourcesContent: false,
 	platform: "node",
 	target: "node20",
-	outfile: path.join(__dirname, "dist", "cli.mjs"),
 	// These modules need to load files from the module directory at runtime
 	external: [
 		"@grpc/reflection",
@@ -237,6 +236,13 @@ const config: esbuild.BuildOptions = {
 		"@vscode/ripgrep", // Uses __dirname to locate the binary
 	],
 	supported: { "top-level-await": true },
+}
+
+// CLI executable configuration
+const cliConfig: esbuild.BuildOptions = {
+	...sharedOptions,
+	entryPoints: [path.join(__dirname, "src", "index.ts")],
+	outfile: path.join(__dirname, "dist", "cli.mjs"),
 	banner: {
 		js: `#!/usr/bin/env node
 // Suppress all Node.js warnings (deprecation, experimental, etc.)
@@ -250,19 +256,44 @@ const __dirname = _dirname(__filename);`,
 	},
 }
 
+// Library configuration for programmatic use
+const libConfig: esbuild.BuildOptions = {
+	...sharedOptions,
+	entryPoints: [path.join(__dirname, "src", "exports.ts")],
+	outfile: path.join(__dirname, "dist", "lib.mjs"),
+	banner: {
+		js: `// Cline Library - Programmatic API
+import { createRequire as _createRequire } from 'module';
+import { fileURLToPath as _fileURLToPath } from 'url';
+import { dirname as _dirname } from 'path';
+const require = _createRequire(import.meta.url);
+const __filename = _fileURLToPath(import.meta.url);
+const __dirname = _dirname(__filename);`,
+	},
+}
+
 async function main() {
-	const ctx = await esbuild.context(config)
 	if (watch) {
+		// In watch mode, only watch the CLI (primary use case for development)
+		const ctx = await esbuild.context(cliConfig)
 		await ctx.watch()
 		console.log("[cli] Watching for changes...")
 	} else {
-		await ctx.rebuild()
-		await ctx.dispose()
+		// Build both CLI and library
+		console.log("[cli esbuild] Building CLI executable...")
+		const cliCtx = await esbuild.context(cliConfig)
+		await cliCtx.rebuild()
+		await cliCtx.dispose()
 
-		// Make the output executable
-		const outfile = path.join(__dirname, "dist", "cli.mjs")
-		if (fs.existsSync(outfile)) {
-			fs.chmodSync(outfile, "755")
+		console.log("[cli esbuild] Building library bundle...")
+		const libCtx = await esbuild.context(libConfig)
+		await libCtx.rebuild()
+		await libCtx.dispose()
+
+		// Make the CLI output executable
+		const cliOutfile = path.join(__dirname, "dist", "cli.mjs")
+		if (fs.existsSync(cliOutfile)) {
+			fs.chmodSync(cliOutfile, "755")
 		}
 	}
 }

cli/man/cline.1

@@ -125,13 +125,13 @@ authentication wizard, or use quick setup flags.
 Options:
 .PP
 \f[B]\-p\f[R], \f[B]\-\-provider\f[R] \f[I]id\f[R] : Provider ID for
-quick setup (e.g., openai\-native, anthropic, openrouter)
+quick setup (e.g., openai\-native, anthropic, openrouter, moonshot)
 .PP
 \f[B]\-k\f[R], \f[B]\-\-apikey\f[R] \f[I]key\f[R] : API key for the
 provider
 .PP
 \f[B]\-m\f[R], \f[B]\-\-modelid\f[R] \f[I]id\f[R] : Model ID to
-configure (e.g., gpt\-4o, claude\-sonnet\-4\-5\-20250929)
+configure (e.g., gpt\-4o, claude\-sonnet\-4\-5\-20250929, kimi\-k2.5)
 .PP
 \f[B]\-b\f[R], \f[B]\-\-baseurl\f[R] \f[I]url\f[R] : Base URL (optional,
 for OpenAI\-compatible providers)
@@ -242,6 +242,9 @@ cline \-m claude\-sonnet\-4\-5\-20250929 \(dqRefactor this function\(dq
 
 \f[I]# Quick auth setup with model\f[R]
 cline auth \-p anthropic \-k sk\-ant\-xxxxx \-m claude\-sonnet\-4\-5\-20250929
+
+\f[I]# Quick auth setup for Moonshot\f[R]
+cline auth \-p moonshot \-k sk\-xxxxx \-m kimi\-k2.5
 .EE
 .SS Including Images
 .IP
@@ -309,6 +312,9 @@ cline auth \-p anthropic \-k sk\-ant\-api\-xxxxx
 \f[I]# Quick setup for OpenAI\f[R]
 cline auth \-p openai\-native \-k sk\-xxxxx \-m gpt\-4o
 
+\f[I]# Quick setup for Moonshot\f[R]
+cline auth \-p moonshot \-k sk\-xxxxx \-m kimi\-k2.5
+
 \f[I]# OpenAI\-compatible provider with custom base URL\f[R]
 cline auth \-p openai \-k your\-api\-key \-b https://api.example.com/v1
 .EE

cli/man/cline.1.md

@@ -56,6 +56,8 @@ Run a new task with a prompt.
 
 **-y**, **\--yolo** :   Enable yolo/yes mode (auto-approve all actions, output in plain mode, exit process automatically when task complete)
 
+**-t**, **\--timeout** *seconds* :   Optional timeout in seconds. Only applied when explicitly provided.
+
 **-m**, **\--model** *model* :   Model to use for the task
 
 **-i**, **\--images** *paths...* :   Image file paths to include with the task
@@ -144,6 +146,8 @@ When running **cline** with just a prompt (no subcommand), these options are ava
 
 **-y**, **\--yolo** :   Enable yolo mode (auto-approve all actions). Also forces plain text output mode.
 
+**-t**, **\--timeout** *seconds* :   Optional timeout in seconds. Only applied when explicitly provided.
+
 **-m**, **\--model** *model* :   Model to use for the task
 
 **-v**, **\--verbose** :   Show verbose output

cli/package.json

@@ -1,11 +1,18 @@
 {
 	"name": "cline",
-	"version": "2.2.2",
+	"version": "2.5.1",
 	"description": "Autonomous coding agent CLI - capable of creating/editing files, running commands, using the browser, and more",
-	"main": "dist/cli.mjs",
+	"main": "dist/lib.mjs",
+	"types": "dist/lib.d.ts",
 	"bin": {
 		"cline": "./dist/cli.mjs"
 	},
+	"exports": {
+		".": {
+			"import": "./dist/lib.mjs",
+			"types": "./dist/lib.d.ts"
+		}
+	},
 	"os": [
 		"darwin",
 		"linux",
@@ -23,8 +30,9 @@
 	"scripts": {
 		"package:brew": "npx tsx ./scripts/update-brew-formula.mts",
 		"package": "npm pack --pack-destination ./dist",
-		"build": "npm run typecheck && npx tsx esbuild.mts",
-		"build:production": "npm run typecheck && npx tsx esbuild.mts --production",
+		"build": "npm run typecheck && npx tsx esbuild.mts && npm run build:types",
+		"build:production": "npm run typecheck && npx tsx esbuild.mts --production && npm run build:types",
+		"build:types": "(npx tsc -p tsconfig.lib.json || true) && cp dist/types/cli/src/exports.d.ts dist/lib.d.ts && mkdir -p dist/agent && cp dist/types/cli/src/agent/ClineAgent.d.ts dist/types/cli/src/agent/ClineSessionEmitter.d.ts dist/types/cli/src/agent/public-types.d.ts dist/agent/ && rm -rf dist/types",
 		"watch": "npx tsx esbuild.mts --watch",
 		"dev": "IS_DEV=true && npm run link && npm run watch ; npm run unlink",
 		"clean": "rimraf dist",
@@ -62,6 +70,7 @@
 		"url": "https://github.com/cline/cline/issues"
 	},
 	"devDependencies": {
+		"@types/marked": "^5.0.2",
 		"@types/node": "20.x",
 		"@types/prompts": "^2.4.9",
 		"@types/react": "^19.2.9",
@@ -81,8 +90,9 @@
 		"ink": "npm:@jrichman/ink@6.4.7",
 		"ink-picture": "^1.3.3",
 		"ink-spinner": "^5.0.0",
-		"ora": "^8.0.1",
+		"marked": "^17.0.3",
 		"nanoid": "^5.1.6",
+		"ora": "^8.0.1",
 		"pino": "^10.0.0",
 		"pino-roll": "^4.0.0",
 		"prompts": "^2.4.2",

cli/src/acp/ACPHostBridgeClientProvider.ts

@@ -108,11 +108,7 @@ class ACPDiffServiceClient implements DiffServiceClientInterface {
 class ACPEnvServiceClient implements EnvServiceClientInterface {
 	private readonly version: string
 
-	constructor(
-		_clientCapabilities: acp.ClientCapabilities | undefined,
-		_sessionIdResolver: SessionIdResolver,
-		version: string = "1.0.0",
-	) {
+	constructor(_clientCapabilities: acp.ClientCapabilities | undefined, _sessionIdResolver: SessionIdResolver, version: string) {
 		this.version = version
 	}
 
@@ -402,7 +398,7 @@ export class ACPHostBridgeClientProvider implements HostBridgeClientProvider {
 		clientCapabilities: acp.ClientCapabilities | undefined,
 		sessionIdResolver: SessionIdResolver,
 		cwdResolver: CwdResolver,
-		version: string = "1.0.0",
+		version: string,
 	) {
 		this.workspaceClient = new ACPWorkspaceServiceClient(clientCapabilities, sessionIdResolver, cwdResolver)
 		this.envClient = new ACPEnvServiceClient(clientCapabilities, sessionIdResolver, version)

cli/src/acp/AcpAgent.ts

@@ -15,7 +15,7 @@
 import type * as acp from "@agentclientprotocol/sdk"
 import { Logger } from "@/shared/services/Logger.js"
 import { ClineAgent } from "../agent/ClineAgent.js"
-import type { AcpAgentOptions, SessionUpdateType } from "../agent/types.js"
+import { type AcpAgentOptions, type SessionUpdateType } from "../agent/types.js"
 
 /**
  * ACP Agent wrapper that bridges stdio connection to ClineAgent.
@@ -39,37 +39,21 @@ export class AcpAgent implements acp.Agent {
 		this.clineAgent = new ClineAgent(options)
 
 		// Wire up the permission handler to use the connection
-		this.clineAgent.setPermissionHandler(async (request, resolve) => {
+		this.clineAgent.setPermissionHandler(async (request) => {
 			try {
 				Logger.debug("[AcpAgent] Forwarding permission request to connection")
-				const response = await this.connection.requestPermission({
-					sessionId: this.getCurrentSessionId() ?? "",
+				return await this.connection.requestPermission({
+					sessionId: request.sessionId,
 					toolCall: request.toolCall,
 					options: request.options,
 				})
-				resolve(response)
 			} catch (error) {
 				Logger.debug("[AcpAgent] Error requesting permission:", error)
-				resolve({ outcome: "rejected" as unknown as acp.RequestPermissionOutcome })
+				return { outcome: { outcome: "cancelled" } }
 			}
 		})
 	}
 
-	/**
-	 * Get the current active session ID from the ClineAgent.
-	 */
-	private getCurrentSessionId(): string | undefined {
-		// Find the session that's currently processing
-		for (const [sessionId, session] of this.clineAgent.sessions) {
-			if (session.controller?.task) {
-				return sessionId
-			}
-		}
-		// Fall back to the first session if none is actively processing
-		const firstSession = this.clineAgent.sessions.keys().next()
-		return firstSession.done ? undefined : firstSession.value
-	}
-
 	/**
 	 * Subscribe to session events and forward them to the connection.
 	 */

cli/src/acp/index.ts

@@ -15,22 +15,18 @@
 
 import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk"
 import { Logger } from "@/shared/services/Logger"
-import { version as CLI_VERSION } from "../../../package.json"
 import { AcpAgent } from "./AcpAgent.js"
 import { nodeToWebReadable, nodeToWebWritable } from "./streamUtils.js"
 
 // Re-export classes for programmatic use
 export { ClineAgent } from "../agent/ClineAgent.js"
 export { ClineSessionEmitter } from "../agent/ClineSessionEmitter.js"
-// Re-export types
 export type {
 	AcpAgentOptions,
 	AcpSessionState,
-	ClineAcpSession,
 	ClineAgentOptions,
 	ClineSessionEvents,
 	PermissionHandler,
-	PermissionResolver,
 } from "../agent/types.js"
 export { AcpAgent } from "./AcpAgent.js"
 
@@ -99,7 +95,6 @@ export async function runAcpMode(options: AcpModeOptions = {}): Promise<void> {
 
 	new AgentSideConnection((conn) => {
 		agent = new AcpAgent(conn, {
-			version: CLI_VERSION,
 			debug: Boolean(options.verbose),
 		})
 		return agent

cli/src/agent/ClineAgent.ts

@@ -28,6 +28,8 @@ import {
 	groqModels,
 	mistralDefaultModelId,
 	mistralModels,
+	moonshotDefaultModelId,
+	moonshotModels,
 	openAiCodexDefaultModelId,
 	openAiNativeDefaultModelId,
 	openAiNativeModels,
@@ -36,7 +38,6 @@ import {
 } from "@shared/api"
 import type { ClineAsk, ClineMessage as ClineMessageType } from "@shared/ExtensionMessage"
 import { CLI_ONLY_COMMANDS, VSCODE_ONLY_COMMANDS } from "@shared/slashCommands"
-import { ProviderToApiKeyMap } from "@shared/storage"
 import { getProviderModelIdKey } from "@shared/storage/provider-keys"
 import { ClineEndpoint } from "@/config.js"
 import { Controller } from "@/core/controller"
@@ -51,18 +52,21 @@ import { openAiCodexOAuthManager } from "@/integrations/openai-codex/oauth"
 import { StandaloneTerminalManager } from "@/integrations/terminal/index.js"
 import { AuthService } from "@/services/auth/AuthService.js"
 import { Logger } from "@/shared/services/Logger.js"
-import { secretStorage } from "@/shared/storage/ClineSecretStorage"
 import type { Mode } from "@/shared/storage/types"
 import { openExternal } from "@/utils/env"
+import { version as AGENT_VERSION } from "../../package.json"
 import { ACPDiffViewProvider } from "../acp/ACPDiffViewProvider.js"
 import { ACPHostBridgeClientProvider } from "../acp/ACPHostBridgeClientProvider.js"
 import { AcpTerminalManager } from "../acp/AcpTerminalManager.js"
+import { isAuthConfigured } from "../utils/auth"
 import { fetchOpenRouterModels, usesOpenRouterModels } from "../utils/openrouter-models"
 import { CliContextResult, initializeCliContext } from "../vscode-context.js"
 import { ClineSessionEmitter } from "./ClineSessionEmitter.js"
 import { translateMessage } from "./messageTranslator.js"
 import { handlePermissionResponse } from "./permissionHandler.js"
-import type { AcpSessionState, ClineAcpSession, ClineAgentOptions, PermissionHandler } from "./types.js"
+import type { ClineAcpSession, ClineAgentOptions, PermissionHandler } from "./public-types.js"
+import { AcpSessionStatus } from "./public-types.js"
+import { type AcpSessionState } from "./types.js"
 
 // Map providers to their static model lists and defaults (copied from ModelPicker.tsx)
 const providerModels: Record<string, { models: Record<string, unknown>; defaultId: string }> = {
@@ -72,6 +76,7 @@ const providerModels: Record<string, { models: Record<string, unknown>; defaultI
 	bedrock: { models: bedrockModels, defaultId: bedrockDefaultModelId },
 	deepseek: { models: deepSeekModels, defaultId: deepSeekDefaultModelId },
 	mistral: { models: mistralModels, defaultId: mistralDefaultModelId },
+	moonshot: { models: moonshotModels, defaultId: moonshotDefaultModelId },
 	groq: { models: groqModels, defaultId: groqDefaultModelId },
 	xai: { models: xaiModels, defaultId: xaiDefaultModelId },
 }
@@ -102,7 +107,12 @@ function getModelList(provider: string): string[] {
 export class ClineAgent implements acp.Agent {
 	private readonly options: ClineAgentOptions
 	private readonly ctx: CliContextResult
-	readonly sessions: Map<string, ClineAcpSession> = new Map()
+
+	/** Map of active sessions by session ID */
+	public readonly sessions: Map<string, ClineAcpSession> = new Map()
+
+	/** WeakMap to associate ClineAcpSession with its Controller without exposing it to consumers */
+	readonly #sessionControllers = new WeakMap<ClineAcpSession, Controller>()
 
 	/** Runtime state for active sessions */
 	private readonly sessionStates: Map<string, AcpSessionState> = new Map()
@@ -130,7 +140,7 @@ export class ClineAgent implements acp.Agent {
 
 	constructor(options: ClineAgentOptions) {
 		this.options = options
-		this.ctx = initializeCliContext()
+		this.ctx = initializeCliContext({ clineDir: options.clineDir })
 	}
 
 	/**
@@ -174,7 +184,7 @@ export class ClineAgent implements acp.Agent {
 		this.clientCapabilities = params.clientCapabilities
 		this.initializeHostProvider(this.clientCapabilities, connection)
 		await ClineEndpoint.initialize(this.ctx.EXTENSION_DIR)
-		await StateManager.initialize(this.ctx.extensionContext)
+		await StateManager.initialize(this.ctx.storageContext)
 
 		return {
 			protocolVersion: PROTOCOL_VERSION,
@@ -192,7 +202,7 @@ export class ClineAgent implements acp.Agent {
 			},
 			agentInfo: {
 				name: "cline",
-				version: this.options.version,
+				version: AGENT_VERSION,
 			},
 			authMethods: [
 				{
@@ -224,7 +234,7 @@ export class ClineAgent implements acp.Agent {
 			clientCapabilities,
 			() => this.currentActiveSessionId,
 			() => this.sessions.get(this.currentActiveSessionId ?? "")?.cwd ?? process.cwd(),
-			this.options.version,
+			AGENT_VERSION,
 		)
 
 		HostProvider.initialize(
@@ -263,7 +273,7 @@ export class ClineAgent implements acp.Agent {
 	 */
 	async newSession(params: acp.NewSessionRequest): Promise<acp.NewSessionResponse> {
 		// Check if authentication is required
-		const isAuthenticated = await this.isAuthConfigured()
+		const isAuthenticated = await isAuthConfigured()
 		if (!isAuthenticated) {
 			throw RequestError.authRequired()
 		}
@@ -287,16 +297,16 @@ export class ClineAgent implements acp.Agent {
 			mcpServers: params.mcpServers ?? [],
 			createdAt: Date.now(),
 			lastActivityAt: Date.now(),
-			controller,
 		}
 
+		this.#sessionControllers.set(session, controller)
+
 		this.sessions.set(sessionId, session)
 
 		// Initialize session state
 		const sessionState: AcpSessionState = {
 			sessionId,
-			isProcessing: false,
-			cancelled: false,
+			status: AcpSessionStatus.Idle,
 			pendingToolCalls: new Map(),
 		}
 
@@ -433,11 +443,11 @@ export class ClineAgent implements acp.Agent {
 	 *
 	 * The prompt flow:
 	 * 1. Extract content from the ACP prompt (text, images, files)
-	 * 2. Set up state broadcasting (subscribe to controller updates)
-	 * 3. Initialize or continue task with Controller
+	 * 2. Set up internal cline state subsription
+	 * 3. Initialize or continue cline task
 	 * 4. Translate ClineMessages to ACP SessionUpdates
 	 * 5. Handle permission requests for tools/commands
-	 * 6. Return when task completes, is cancelled, or needs user input
+	 * 6. Return when cline task completes, is cancelled, or needs user input
 	 */
 	async prompt(params: acp.PromptRequest): Promise<acp.PromptResponse> {
 		const session = this.sessions.get(params.sessionId)
@@ -447,11 +457,11 @@ export class ClineAgent implements acp.Agent {
 			throw new Error(`Session not found: ${params.sessionId}`)
 		}
 
-		if (sessionState.isProcessing) {
+		if (sessionState.status === AcpSessionStatus.Processing) {
 			throw new Error(`Session ${params.sessionId} is already processing a prompt`)
 		}
 
-		const controller = session.controller
+		const controller = this.#sessionControllers.get(session)
 		if (!controller) {
 			throw new Error("Controller not initialized for session. This is a bug in the ACP agent setup.")
 		}
@@ -462,8 +472,7 @@ export class ClineAgent implements acp.Agent {
 		})
 
 		// Mark session as processing and set as current active session
-		sessionState.isProcessing = true
-		sessionState.cancelled = false
+		sessionState.status = AcpSessionStatus.Processing
 		session.lastActivityAt = Date.now()
 		this.currentActiveSessionId = params.sessionId
 
@@ -584,7 +593,7 @@ export class ClineAgent implements acp.Agent {
 					Logger.debug("[ClineAgent] Error during cleanup:", error)
 				}
 			}
-			sessionState.isProcessing = false
+			sessionState.status = AcpSessionStatus.Idle
 		}
 	}
 
@@ -646,7 +655,13 @@ export class ClineAgent implements acp.Agent {
 		permissionRequest: Omit<acp.RequestPermissionRequest, "sessionId">,
 	): Promise<void> {
 		const session = this.sessions.get(sessionId)
-		const controller = session?.controller
+
+		if (!session) {
+			Logger.debug("[ClineAgent] No session found for permission request")
+			return
+		}
+
+		const controller = this.#sessionControllers.get(session)
 
 		if (!controller?.task) {
 			Logger.debug("[ClineAgent] No active task for permission request")
@@ -827,7 +842,7 @@ export class ClineAgent implements acp.Agent {
 
 				await this.emitSessionUpdate(sessionId, {
 					sessionUpdate,
-					content: { type: "text", text: needsNewline ? "\n" + textDelta : textDelta },
+					content: { type: "text", text: needsNewline ? `\n${textDelta}` : textDelta },
 				})
 			}
 
@@ -880,18 +895,22 @@ export class ClineAgent implements acp.Agent {
 	 */
 	async cancel(params: acp.CancelNotification): Promise<void> {
 		const session = this.sessions.get(params.sessionId)
+		if (!session) {
+			Logger.debug("[ClineAgent] cancel called for non-existent session:", params.sessionId)
+			return
+		}
 		const sessionState = this.sessionStates.get(params.sessionId)
 
 		Logger.debug("[ClineAgent] cancel called:", {
 			sessionId: params.sessionId,
-			isProcessing: sessionState?.isProcessing,
+			status: sessionState?.status,
 		})
 
 		if (sessionState) {
-			sessionState.cancelled = true
+			sessionState.status = AcpSessionStatus.Cancelled
 
 			// If we have an active controller task, cancel it
-			const controller = session?.controller
+			const controller = this.#sessionControllers.get(session)
 			if (controller?.task) {
 				try {
 					await controller.cancelTask()
@@ -932,7 +951,7 @@ export class ClineAgent implements acp.Agent {
 		session.lastActivityAt = Date.now()
 
 		// Update Controller mode if active
-		const controller = session.controller
+		const controller = this.#sessionControllers.get(session)
 		if (controller) {
 			controller.stateManager.setGlobalState("mode", session.mode)
 
@@ -1004,13 +1023,14 @@ export class ClineAgent implements acp.Agent {
 			const startTime = Date.now()
 
 			while (Date.now() - startTime < AUTH_TIMEOUT_MS) {
+				const stateManager = StateManager.get()
+
 				// Check if auth data has been stored
-				const authData = await secretStorage.get("cline:clineAccountId")
+				const authData = stateManager.getSecretKey("cline:clineAccountId")
 				if (authData) {
 					Logger.debug("[ClineAgent] Authentication successful")
 
 					// Set up the provider configuration for cline
-					const stateManager = StateManager.get()
 					stateManager.setGlobalState("actModeApiProvider", "cline")
 					stateManager.setGlobalState("planModeApiProvider", "cline")
 					await stateManager.flushPendingState()
@@ -1062,7 +1082,7 @@ export class ClineAgent implements acp.Agent {
 	 * @returns The permission response from the client
 	 */
 	protected async requestPermission(
-		_sessionId: string,
+		sessionId: string,
 		toolCall: acp.ToolCallUpdate,
 		options: acp.PermissionOption[],
 	): Promise<acp.RequestPermissionResponse> {
@@ -1077,17 +1097,15 @@ export class ClineAgent implements acp.Agent {
 			return { outcome: "rejected" as unknown as acp.RequestPermissionOutcome }
 		}
 
-		// Use the permission handler callback pattern
-		return new Promise<acp.RequestPermissionResponse>((resolve) => {
-			this.permissionHandler!({ toolCall, options }, resolve)
-		})
+		return await this.permissionHandler({ sessionId, toolCall, options })
 	}
 
 	async shutdown(): Promise<void> {
 		for (const [sessionId, session] of this.sessions) {
-			await session.controller?.task?.abortTask()
-			await session.controller?.stateManager.flushPendingState()
-			await session.controller?.dispose()
+			const controller = this.#sessionControllers.get(session)
+			await controller?.task?.abortTask()
+			await controller?.stateManager.flushPendingState()
+			await controller?.dispose()
 			this.sessions.delete(sessionId)
 			this.sessionStates.delete(sessionId)
 		}
@@ -1143,48 +1161,6 @@ export class ClineAgent implements acp.Agent {
 		}
 	}
 
-	/**
-	 * Check if the user has authentication configured.
-	 * Returns true if they have either:
-	 * - Cline provider with stored auth data
-	 * - OpenAI Codex provider with OAuth credentials
-	 * - BYO provider with an API key configured
-	 */
-	private async isAuthConfigured(): Promise<boolean> {
-		const stateManager = StateManager.get()
-		const mode = stateManager.getGlobalSettingsKey("mode") as string
-		const providerKey = mode === "act" ? "actModeApiProvider" : "planModeApiProvider"
-		const currentProvider = (stateManager.getGlobalSettingsKey(providerKey) as string) || "cline"
-
-		if (currentProvider === "cline") {
-			// For Cline provider, check if we have stored auth data
-			const values = await Promise.all(["clineApiKey", "clineAccountId"].map((key) => secretStorage.get(key)))
-			return values.some(Boolean)
-		}
-
-		// For OpenAI Codex provider, check OAuth credentials
-		if (currentProvider === "openai-codex") {
-			openAiCodexOAuthManager.initialize(this.ctx.extensionContext)
-			return await openAiCodexOAuthManager.isAuthenticated()
-		}
-
-		// For BYO providers, check if the API key is configured
-		const keyField = ProviderToApiKeyMap[currentProvider as keyof typeof ProviderToApiKeyMap]
-		if (!keyField) {
-			return false
-		}
-
-		const fields = Array.isArray(keyField) ? keyField : [keyField]
-		for (const field of fields) {
-			const value = await secretStorage.get(field)
-			if (value) {
-				return true
-			}
-		}
-
-		return false
-	}
-
 	/**
 	 * Handle OpenAI Codex OAuth authentication flow.
 	 *
@@ -1198,9 +1174,6 @@ export class ClineAgent implements acp.Agent {
 		Logger.debug("[ClineAgent] Starting OpenAI Codex OAuth flow...")
 
 		try {
-			// Initialize the OAuth manager with extension context
-			openAiCodexOAuthManager.initialize(this.ctx.extensionContext)
-
 			// Get the authorization URL and start the callback server
 			const authUrl = openAiCodexOAuthManager.startAuthorizationFlow()
 

cli/src/agent/ClineSessionEmitter.ts

@@ -8,7 +8,7 @@
  */
 
 import { EventEmitter } from "events"
-import type { ClineSessionEvents } from "./types.js"
+import type { ClineSessionEvents } from "./public-types.js"
 
 /**
  * Type-safe EventEmitter for ClineAgent session events.

cli/src/agent/messageTranslator.test.ts

@@ -12,6 +12,7 @@ import type { ClineMessage } from "@shared/ExtensionMessage"
 import { beforeEach, describe, expect, it } from "vitest"
 import { createSessionState, translateMessage, translateMessages } from "./messageTranslator"
 import type { AcpSessionState } from "./types"
+import { AcpSessionStatus } from "./types"
 
 // =============================================================================
 // Test Helpers
@@ -175,8 +176,7 @@ describe("createSessionState", () => {
 		const state = createSessionState("my-session-123")
 
 		expect(state.sessionId).toBe("my-session-123")
-		expect(state.isProcessing).toBe(false)
-		expect(state.cancelled).toBe(false)
+		expect(state.status).toBe(AcpSessionStatus.Idle)
 		expect(state.pendingToolCalls).toBeInstanceOf(Map)
 		expect(state.pendingToolCalls.size).toBe(0)
 		expect(state.currentToolCallId).toBeUndefined()
@@ -187,11 +187,11 @@ describe("createSessionState", () => {
 		const state2 = createSessionState("session-2")
 
 		// Modify state1
-		state1.isProcessing = true
+		state1.status = AcpSessionStatus.Processing
 		state1.pendingToolCalls.set("tool-1", {} as acp.ToolCall)
 
 		// state2 should be unaffected
-		expect(state2.isProcessing).toBe(false)
+		expect(state2.status).toBe(AcpSessionStatus.Idle)
 		expect(state2.pendingToolCalls.size).toBe(0)
 	})
 })

cli/src/agent/messageTranslator.ts

@@ -11,6 +11,7 @@
 import type * as acp from "@agentclientprotocol/sdk"
 import type { ClineMessage, ClineSayBrowserAction, ClineSayTool } from "@shared/ExtensionMessage"
 import type { AcpSessionState, TranslatedMessage } from "./types.js"
+import { AcpSessionStatus } from "./types.js"
 
 /**
  * Maps Cline tool types to ACP ToolKind values.
@@ -1019,8 +1020,7 @@ export function translateMessages(messages: ClineMessage[], sessionState: AcpSes
 export function createSessionState(sessionId: string): AcpSessionState {
 	return {
 		sessionId,
-		isProcessing: false,
-		cancelled: false,
+		status: AcpSessionStatus.Idle,
 		pendingToolCalls: new Map(),
 	}
 }

cli/src/agent/public-types.ts

@@ -0,0 +1,254 @@
+/**
+ * Public types for the Cline library API.
+ *
+ * This file contains types that are safe to export to library consumers.
+ * It must NOT import any internal types (Controller, StateManager, etc.)
+ * to keep the generated declaration files clean.
+ *
+ * Internal-only extensions of these types live in ./types.ts.
+ */
+
+import type * as acp from "@agentclientprotocol/sdk"
+
+// ============================================================
+// Session Update Type Utilities
+// ============================================================
+
+/**
+ * Different types of updates that can be sent during session processing.
+ *
+ * These updates provide real-time feedback about the agent's progress.
+ *
+ * See protocol docs: [Agent Reports Output](https://agentclientprotocol.com/protocol/prompt-turn#3-agent-reports-output)
+ */
+export type SessionUpdateType = acp.SessionUpdate["sessionUpdate"]
+
+/**
+ * Different types of update payloads that can be sent during session processing.
+ *
+ * Each update type has a corresponding payload structure defined in the ACP SessionUpdate union.
+ */
+export type SessionUpdatePayload<T extends SessionUpdateType> = Omit<
+	Extract<acp.SessionUpdate, { sessionUpdate: T }>,
+	"sessionUpdate"
+>
+
+// ============================================================
+// Permission Handler Callback Types
+// ============================================================
+
+/**
+ * Handler function for permission requests.
+ * Called when the agent needs permission for a tool call.
+ * The handler should present the request to the user and call resolve() with their response.
+ */
+export type PermissionHandler = (request: acp.RequestPermissionRequest) => Promise<acp.RequestPermissionResponse>
+
+// ============================================================
+// Session Event Emitter Types
+// ============================================================
+
+/**
+ * Maps ACP SessionUpdate types to their event listener signatures.
+ * Uses the sessionUpdate discriminator to derive event names and payload types.
+ */
+export type ClineSessionEvents = {
+	[K in SessionUpdateType]: (payload: SessionUpdatePayload<K>) => void
+} & {
+	/** Error event for session-level errors (not part of ACP SessionUpdate) */
+	error: (error: Error) => void
+}
+
+// ============================================================
+// ClineAgent Options
+// ============================================================
+
+/**
+ * Options for creating a ClineAgent instance.
+ */
+export interface ClineAgentOptions {
+	/** Whether debug logging is enabled */
+	debug?: boolean
+	/** Cline Config Directory (defaults to ~/.cline) */
+	clineDir?: string
+}
+
+/**
+ * Options for creating an ACP agent instance.
+ */
+export interface AcpAgentOptions {
+	/** Whether debug logging is enabled */
+	debug?: boolean
+}
+
+// ============================================================
+// Session Types
+// ============================================================
+export type SessionID = string
+
+/**
+ * Extended session data stored by Cline for ACP sessions.
+ */
+export interface ClineAcpSession {
+	/** Unique session ID */
+	sessionId: SessionID
+	/** Working directory for the session */
+	cwd: string
+	/** Current mode (plan/act) */
+	mode: "plan" | "act"
+	/** MCP servers passed from the client */
+	mcpServers: acp.McpServer[]
+	/** Timestamp when session was created */
+	createdAt: number
+	/** Timestamp of last activity */
+	lastActivityAt: number
+	/** Whether this session was loaded from history (needs resume on first prompt) */
+	isLoadedFromHistory?: boolean
+	/** Model ID override for plan mode (format: "provider/modelId") */
+	planModeModelId?: string
+	/** Model ID override for act mode (format: "provider/modelId") */
+	actModeModelId?: string
+}
+
+/**
+ * Lifecycle status of an ACP session.
+ *
+ * Represents the state machine:
+ *   Idle → Processing → Idle       (normal completion)
+ *   Idle → Processing → Cancelled  (cancellation, then back to Idle on next prompt)
+ */
+export enum AcpSessionStatus {
+	/** Session is idle, waiting for a prompt */
+	Idle = "idle",
+	/** Session is actively processing a prompt */
+	Processing = "processing",
+	/** Session processing was cancelled */
+	Cancelled = "cancelled",
+}
+
+/**
+ * State tracking for an active ACP session within Cline.
+ */
+export interface AcpSessionState {
+	/** Session ID */
+	sessionId: SessionID
+	/** Current lifecycle status of the session */
+	status: AcpSessionStatus
+	/** Current tool call ID being executed (if any) */
+	currentToolCallId?: string
+	/** Accumulated tool calls for permission batching */
+	pendingToolCalls: Map<string, acp.ToolCall>
+}
+
+// ============================================================
+// Agent Capabilities
+// ============================================================
+
+/**
+ * Cline-specific agent capabilities extending the ACP base capabilities.
+ */
+export interface ClineAgentCapabilities {
+	/** Support for loading sessions from disk */
+	loadSession: boolean
+	/** Prompt capabilities for the agent */
+	promptCapabilities: {
+		/** Support for image inputs */
+		image: boolean
+		/** Support for audio inputs */
+		audio: boolean
+		/** Support for embedded context (file resources) */
+		embeddedContext: boolean
+	}
+	/** MCP server passthrough capabilities */
+	mcpCapabilities: {
+		/** Support for HTTP MCP servers */
+		http: boolean
+		/** Support for SSE MCP servers */
+		sse: boolean
+	}
+}
+
+/**
+ * Cline agent info for ACP initialization response.
+ */
+export interface ClineAgentInfo {
+	name: "cline"
+	title: "Cline"
+	version: string
+}
+
+// ============================================================
+// Permission Options
+// ============================================================
+
+/**
+ * Permission option as presented to the ACP client.
+ */
+export interface ClinePermissionOption {
+	kind: acp.PermissionOptionKind
+	name: string
+	optionId: string
+}
+
+// ============================================================
+// Message Translation
+// ============================================================
+
+/**
+ * Result of translating a Cline message to ACP session update(s).
+ * A single Cline message may produce multiple ACP updates.
+ */
+export interface TranslatedMessage {
+	/** The session updates to send */
+	updates: acp.SessionUpdate[]
+	/** Whether this message requires a permission request */
+	requiresPermission?: boolean
+	/** Permission request details if required */
+	permissionRequest?: Omit<acp.RequestPermissionRequest, "sessionId">
+	/** The toolCallId that was created/used (for tracking across streaming updates) */
+	toolCallId?: string
+}
+
+// ============================================================
+// Re-exported ACP Types
+// ============================================================
+
+export type {
+	Agent,
+	AgentSideConnection,
+	AudioContent,
+	CancelNotification,
+	ClientCapabilities,
+	ContentBlock,
+	ImageContent,
+	InitializeRequest,
+	InitializeResponse,
+	LoadSessionRequest,
+	LoadSessionResponse,
+	McpServer,
+	ModelInfo,
+	NewSessionRequest,
+	NewSessionResponse,
+	PermissionOption,
+	PermissionOptionKind,
+	PromptRequest,
+	PromptResponse,
+	RequestPermissionRequest,
+	RequestPermissionResponse,
+	SessionConfigOption,
+	SessionModelState,
+	SessionNotification,
+	SessionUpdate,
+	SetSessionConfigOptionRequest,
+	SetSessionConfigOptionResponse,
+	SetSessionModelRequest,
+	SetSessionModelResponse,
+	SetSessionModeRequest,
+	SetSessionModeResponse,
+	StopReason,
+	TextContent,
+	ToolCall,
+	ToolCallStatus,
+	ToolCallUpdate,
+	ToolKind,
+} from "@agentclientprotocol/sdk"

cli/src/agent/types.ts

@@ -1,76 +1,13 @@
 /**
- * Custom types and extensions for ACP integration with Cline CLI.
+ * Internal types for ACP integration with Cline CLI.
  *
- * This file extends the base ACP types with Cline-specific functionality.
+ * This file re-exports all public types from ./public-types.ts and adds
+ * internal-only Types that reference core modules (Controller, etc.).
+ *
+ * Library consumers should never import from this file directly — they
+ * get the public types via the library entrypoint (exports.ts).
  */
 
-import type * as acp from "@agentclientprotocol/sdk"
-import type { Controller } from "@/core/controller"
-
-// ============================================================
-// Session Update Type Utilities
-// ============================================================
-
-/**
- * Extract the sessionUpdate discriminator value from a SessionUpdate variant.
- */
-export type SessionUpdateType = acp.SessionUpdate["sessionUpdate"]
-
-/**
- * Extract the payload type for a given sessionUpdate discriminator value.
- * This removes the `sessionUpdate` discriminator field from the type.
- */
-export type SessionUpdatePayload<T extends SessionUpdateType> = Omit<
-	Extract<acp.SessionUpdate, { sessionUpdate: T }>,
-	"sessionUpdate"
->
-
-// ============================================================
-// Permission Handler Callback Types
-// ============================================================
-
-/**
- * Callback to resolve a permission request with the user's response.
- */
-export type PermissionResolver = (response: acp.RequestPermissionResponse) => void
-
-/**
- * Handler function for permission requests.
- * Called when the agent needs permission for a tool call.
- * The handler should present the request to the user and call resolve() with their response.
- */
-export type PermissionHandler = (request: Omit<acp.RequestPermissionRequest, "sessionId">, resolve: PermissionResolver) => void
-
-// ============================================================
-// Session Event Emitter Types
-// ============================================================
-
-/**
- * Maps ACP SessionUpdate types to their event listener signatures.
- * Uses the sessionUpdate discriminator to derive event names and payload types.
- */
-export type ClineSessionEvents = {
-	[K in SessionUpdateType]: (payload: SessionUpdatePayload<K>) => void
-} & {
-	/** Error event for session-level errors (not part of ACP SessionUpdate) */
-	error: (error: Error) => void
-}
-
-// ============================================================
-// ClineAgent Options (decoupled from connection)
-// ============================================================
-
-/**
- * Options for creating a ClineAgent instance (decoupled from connection).
- */
-export interface ClineAgentOptions {
-	/** CLI version string */
-	version: string
-	/** Whether debug logging is enabled */
-	debug?: boolean
-}
-
-// Re-export common ACP types for convenience
 export type {
 	Agent,
 	AgentSideConnection,
@@ -114,134 +51,18 @@ export type {
 	WriteTextFileResponse,
 } from "@agentclientprotocol/sdk"
 
-/**
- * Cline-specific agent capabilities extending the ACP base capabilities.
- */
-export interface ClineAgentCapabilities {
-	/** Support for loading sessions from disk */
-	loadSession: boolean
-	/** Prompt capabilities for the agent */
-	promptCapabilities: {
-		/** Support for image inputs */
-		image: boolean
-		/** Support for audio inputs */
-		audio: boolean
-		/** Support for embedded context (file resources) */
-		embeddedContext: boolean
-	}
-	/** MCP server passthrough capabilities */
-	mcpCapabilities: {
-		/** Support for HTTP MCP servers */
-		http: boolean
-		/** Support for SSE MCP servers */
-		sse: boolean
-	}
-}
+export type {
+	AcpAgentOptions,
+	AcpSessionState,
+	ClineAgentCapabilities,
+	ClineAgentInfo,
+	ClineAgentOptions,
+	ClinePermissionOption,
+	ClineSessionEvents,
+	PermissionHandler,
+	SessionUpdatePayload,
+	SessionUpdateType,
+	TranslatedMessage,
+} from "./public-types.js"
 
-/**
- * Cline agent info for ACP initialization response.
- */
-export interface ClineAgentInfo {
-	name: "cline"
-	title: "Cline"
-	version: string
-}
-
-/**
- * Extended session data stored by Cline for ACP sessions.
- * Maps to Cline's task history structure.
- */
-export interface ClineAcpSession {
-	/** Unique session/task ID */
-	sessionId: string
-	/** Working directory for the session */
-	cwd: string
-	/** Current mode (plan/act) */
-	mode: "plan" | "act"
-	/** MCP servers passed from the client */
-	mcpServers: acp.McpServer[]
-	/** Timestamp when session was created */
-	createdAt: number
-	/** Timestamp of last activity */
-	lastActivityAt: number
-	/** Whether this session was loaded from history (needs resume on first prompt) */
-	isLoadedFromHistory?: boolean
-	/** Controller instance for this session (manages task execution) */
-	controller?: Controller
-	/** Model ID override for plan mode (format: "provider/modelId") */
-	planModeModelId?: string
-	/** Model ID override for act mode (format: "provider/modelId") */
-	actModeModelId?: string
-}
-
-/**
- * Permission option as presented to the ACP client.
- */
-export interface ClinePermissionOption {
-	kind: acp.PermissionOptionKind
-	name: string
-	optionId: string
-}
-
-/**
- * Mapping of Cline message types to their ACP session update equivalents.
- */
-export type ClineToAcpUpdateMapping = {
-	/** Text messages from the agent */
-	text: "agent_message_chunk"
-	/** Reasoning/thinking from the agent */
-	reasoning: "agent_thought_chunk"
-	/** Markdown content from the agent */
-	markdown: "agent_message_chunk"
-	/** Tool execution */
-	tool: "tool_call"
-	/** Command execution */
-	command: "tool_call"
-	/** Command output */
-	command_output: "tool_call_update"
-	/** Task completion */
-	completion_result: "end_turn"
-	/** Error messages */
-	error: "tool_call_update" | "error"
-}
-
-/**
- * Options for creating an ACP agent instance.
- */
-export interface AcpAgentOptions {
-	/** CLI version string */
-	version: string
-	/** Whether debug logging is enabled */
-	debug?: boolean
-}
-
-/**
- * Result of translating a Cline message to ACP session update(s).
- * A single Cline message may produce multiple ACP updates.
- */
-export interface TranslatedMessage {
-	/** The session updates to send */
-	updates: acp.SessionUpdate[]
-	/** Whether this message requires a permission request */
-	requiresPermission?: boolean
-	/** Permission request details if required */
-	permissionRequest?: Omit<acp.RequestPermissionRequest, "sessionId">
-	/** The toolCallId that was created/used (for tracking across streaming updates) */
-	toolCallId?: string
-}
-
-/**
- * State tracking for an active ACP session within Cline.
- */
-export interface AcpSessionState {
-	/** Session ID */
-	sessionId: string
-	/** Whether the session is currently processing a prompt */
-	isProcessing: boolean
-	/** Current tool call ID being executed (if any) */
-	currentToolCallId?: string
-	/** Whether the session has been cancelled */
-	cancelled: boolean
-	/** Accumulated tool calls for permission batching */
-	pendingToolCalls: Map<string, acp.ToolCall>
-}
+export { AcpSessionStatus } from "./public-types.js"

cli/src/components/AuthView.tsx

@@ -15,6 +15,7 @@ import { StringRequest } from "@/shared/proto/cline/common"
 import { openExternal } from "@/utils/env"
 import { COLORS } from "../constants/colors"
 import { useStdinContext } from "../context/StdinContext"
+import { useClineFeaturedModels } from "../hooks/useClineFeaturedModels"
 import { useOcaAuth } from "../hooks/useOcaAuth"
 import { useScrollableList } from "../hooks/useScrollableList"
 import { type DetectedSources, detectImportSources, type ImportSource } from "../utils/import-configs"
@@ -23,6 +24,7 @@ import { applyBedrockConfig, applyProviderConfig } from "../utils/provider-confi
 import { useValidProviders } from "../utils/providers"
 import { ApiKeyInput } from "./ApiKeyInput"
 import { StaticRobotFrame } from "./AsciiMotionCli"
+import { BedrockCustomModelFlow } from "./BedrockCustomModelFlow"
 import { type BedrockConfig, BedrockSetup } from "./BedrockSetup"
 import {
 	FeaturedModelPicker,
@@ -31,7 +33,7 @@ import {
 	isBrowseAllSelected,
 } from "./FeaturedModelPicker"
 import { ImportView } from "./ImportView"
-import { getDefaultModelId, hasModelPicker, ModelPicker } from "./ModelPicker"
+import { CUSTOM_MODEL_ID, getDefaultModelId, hasModelPicker, ModelPicker } from "./ModelPicker"
 import { OcaEmployeeCheck } from "./OcaEmployeeCheck"
 import { getProviderLabel } from "./ProviderPicker"
 
@@ -51,6 +53,7 @@ type AuthStep =
 	| "openai_codex_auth"
 	| "bedrock"
 	| "import"
+	| "bedrock_custom"
 
 interface AuthViewProps {
 	controller: any
@@ -76,7 +79,7 @@ const Select: React.FC<{
 	const [selectedIndex, setSelectedIndex] = useState(0)
 
 	useInput(
-		(input, key) => {
+		(_, key) => {
 			if (key.upArrow) {
 				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : items.length - 1))
 			} else if (key.downArrow) {
@@ -142,7 +145,11 @@ const TextInput: React.FC<{
 
 	return (
 		<Box>
-			<Text color="white">{displayValue || placeholder || ""}</Text>
+			{!displayValue && placeholder ? (
+				<Text color="gray">e.g. {placeholder}</Text>
+			) : (
+				<Text color="white">{displayValue || ""}</Text>
+			)}
 			<Text inverse> </Text>
 		</Box>
 	)
@@ -166,6 +173,7 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 	const [providerSearch, setProviderSearch] = useState("")
 	const [providerIndex, setProviderIndex] = useState(0)
 	const [clineModelIndex, setClineModelIndex] = useState(0)
+	const featuredModels = useClineFeaturedModels()
 	const [importSources, setImportSources] = useState<DetectedSources>({ codex: false, opencode: false })
 	const [importSource, setImportSource] = useState<ImportSource | null>(null)
 	const [bedrockConfig, setBedrockConfig] = useState<BedrockConfig | null>(null)
@@ -248,6 +256,7 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 	}, [])
 
 	// Reset provider index when search changes
+	// biome-ignore lint/correctness/useExhaustiveDependencies: we want to reset here
 	useEffect(() => {
 		setProviderIndex(0)
 	}, [providerSearch])
@@ -273,7 +282,7 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 				return
 			}
 
-			if (authState.user && authState.user.email) {
+			if (authState.user?.email) {
 				// Auth succeeded - save configuration and transition to model selection
 				await applyProviderConfig({ providerId: "cline", controller })
 				setSelectedProvider("cline")
@@ -389,6 +398,33 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 		[selectedProvider],
 	)
 
+	// Save custom Bedrock ARN configuration with base model for capability detection
+	const saveCustomBedrockConfiguration = useCallback(
+		async (arn: string, baseModelId: string) => {
+			try {
+				if (!bedrockConfig) {
+					throw new Error("Bedrock configuration is missing")
+				}
+				await applyBedrockConfig({
+					bedrockConfig,
+					modelId: arn,
+					customModelBaseId: baseModelId,
+					controller,
+				})
+
+				const stateManager = StateManager.get()
+				stateManager.setGlobalState("welcomeViewCompleted", true)
+				await stateManager.flushPendingState()
+
+				setStep("success")
+			} catch (error) {
+				setErrorMessage(error instanceof Error ? error.message : String(error))
+				setStep("error")
+			}
+		},
+		[bedrockConfig, controller],
+	)
+
 	const saveConfiguration = useCallback(
 		async (model: string, base: string) => {
 			try {
@@ -423,6 +459,12 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 
 	const handleModelIdSubmit = useCallback(
 		(value: string) => {
+			// Intercept "Custom" selection for Bedrock — redirect to custom ARN input flow
+			if (value === CUSTOM_MODEL_ID && selectedProvider === "bedrock") {
+				setStep("bedrock_custom")
+				return
+			}
+
 			if (value.trim()) {
 				setModelId(value)
 			}
@@ -530,6 +572,9 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 				// Go back to cline_model if we came from there (Cline provider)
 				if (selectedProvider === "cline") {
 					setStep("cline_model")
+				} else if (selectedProvider === "bedrock") {
+					// Bedrock skips the API key step — go back to Bedrock setup
+					setStep("bedrock")
 				} else {
 					setStep("apikey")
 				}
@@ -646,7 +691,7 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 					<Box flexDirection="column">
 						<Text color="white">Model ID</Text>
 						<Text> </Text>
-						<Text color="gray">e.g., claude-sonnet-4-20250514, gpt-4o</Text>
+						<Text color="gray">e.g., claude-sonnet-4-6, gpt-4o</Text>
 						<Text> </Text>
 						<TextInput onChange={setModelId} onSubmit={handleModelIdSubmit} placeholder="model-id" value={modelId} />
 						<Text> </Text>
@@ -724,7 +769,7 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 					<Box flexDirection="column">
 						<Text color="white">Choose a model</Text>
 						<Text> </Text>
-						<FeaturedModelPicker selectedIndex={clineModelIndex} />
+						<FeaturedModelPicker featuredModels={featuredModels} selectedIndex={clineModelIndex} />
 					</Box>
 				)
 			}
@@ -741,6 +786,18 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 					/>
 				)
 
+			case "bedrock_custom":
+				return (
+					<BedrockCustomModelFlow
+						isActive={step === "bedrock_custom"}
+						onCancel={() => setStep("modelid")}
+						onComplete={(arn, baseModelId) => {
+							setStep("saving")
+							saveCustomBedrockConfiguration(arn, baseModelId)
+						}}
+					/>
+				)
+
 			case "import":
 				if (!importSource) {
 					return null
@@ -814,17 +871,17 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 					setProviderSearch((prev) => prev + input)
 				}
 			} else if (step === "cline_model") {
-				const maxIndex = getFeaturedModelMaxIndex()
+				const maxIndex = getFeaturedModelMaxIndex(featuredModels)
 
 				if (key.upArrow) {
 					setClineModelIndex((prev) => (prev > 0 ? prev - 1 : maxIndex))
 				} else if (key.downArrow) {
 					setClineModelIndex((prev) => (prev < maxIndex ? prev + 1 : 0))
 				} else if (key.return) {
-					if (isBrowseAllSelected(clineModelIndex)) {
+					if (isBrowseAllSelected(clineModelIndex, featuredModels)) {
 						setStep("modelid")
 					} else {
-						const selectedModel = getFeaturedModelAtIndex(clineModelIndex)
+						const selectedModel = getFeaturedModelAtIndex(clineModelIndex, featuredModels)
 						if (selectedModel) {
 							handleClineModelSelect(selectedModel.id)
 						}

cli/src/components/BedrockCustomModelFlow.tsx

@@ -0,0 +1,111 @@
+/**
+ * Bedrock Custom Model Flow component
+ * Two-step flow: ARN/custom model ID input → base model selection for capability detection.
+ * Used by both AuthView (onboarding) and SettingsPanelContent (/settings).
+ */
+
+import { Box, Text, useInput } from "ink"
+// biome-ignore lint/correctness/noUnusedImports: React is needed for JSX at runtime
+import React, { useCallback, useState } from "react"
+import { COLORS } from "../constants/colors"
+import { useStdinContext } from "../context/StdinContext"
+import { getModelList } from "./ModelPicker"
+import { SearchableList } from "./SearchableList"
+
+type FlowStep = "arn_input" | "base_model"
+
+interface BedrockCustomModelFlowProps {
+	/** Whether this component should capture keyboard input */
+	isActive: boolean
+	/** Called when the user completes both steps (ARN + base model selection) */
+	onComplete: (arn: string, baseModelId: string) => void
+	/** Called when the user presses Escape on the first step (ARN input) */
+	onCancel: () => void
+}
+
+export const BedrockCustomModelFlow: React.FC<BedrockCustomModelFlowProps> = ({ isActive, onComplete, onCancel }) => {
+	const { isRawModeSupported } = useStdinContext()
+	const [step, setStep] = useState<FlowStep>("arn_input")
+	const [customArn, setCustomArn] = useState("")
+
+	const handleArnSubmit = useCallback(() => {
+		if (customArn.trim()) {
+			setStep("base_model")
+		}
+	}, [customArn])
+
+	const handleBaseModelCancel = useCallback(() => {
+		setStep("arn_input")
+	}, [])
+
+	useInput(
+		(input, key) => {
+			if (step === "arn_input") {
+				if (key.escape) {
+					onCancel()
+				} else if (key.return) {
+					handleArnSubmit()
+				} else if (key.backspace || key.delete) {
+					setCustomArn((prev) => prev.slice(0, -1))
+				} else if (input && !key.ctrl && !key.meta) {
+					setCustomArn((prev) => prev + input)
+				}
+				return
+			}
+
+			if (step === "base_model") {
+				if (key.escape) {
+					handleBaseModelCancel()
+				}
+				// Other input is handled by SearchableList
+			}
+		},
+		{ isActive: isActive && isRawModeSupported },
+	)
+
+	if (step === "arn_input") {
+		return (
+			<Box flexDirection="column">
+				<Text bold color={COLORS.primaryBlue}>
+					Custom Model ID
+				</Text>
+				<Box marginTop={1}>
+					<Text color="gray">Enter your Application Inference Profile ARN or custom model ID</Text>
+				</Box>
+				<Box marginTop={1}>
+					{customArn ? (
+						<Text color="white">{customArn}</Text>
+					) : (
+						<Text color="gray">e.g. arn:aws:bedrock:region:account:application-inference-profile/...</Text>
+					)}
+					<Text inverse> </Text>
+				</Box>
+				<Box marginTop={1}>
+					<Text color="gray">Enter to continue, Esc to go back</Text>
+				</Box>
+			</Box>
+		)
+	}
+
+	// step === "base_model"
+	return (
+		<Box flexDirection="column">
+			<Text bold color={COLORS.primaryBlue}>
+				Base Inference Model
+			</Text>
+			<Text color="gray">Select the base model your inference profile uses (for capability detection)</Text>
+			<Box marginTop={1}>
+				<SearchableList
+					isActive={isActive && step === "base_model"}
+					items={getModelList("bedrock").map((id) => ({ id, label: id }))}
+					onSelect={(item) => {
+						onComplete(customArn, item.id)
+					}}
+				/>
+			</Box>
+			<Box marginTop={1}>
+				<Text color="gray">Type to search, arrows to navigate, Enter to select, Esc to go back</Text>
+			</Box>
+		</Box>
+	)
+}

cli/src/components/BedrockSetup.tsx

@@ -114,8 +114,11 @@ export const BedrockSetup: React.FC<BedrockSetupProps> = ({ isActive, onComplete
 
 	// Filtered regions
 	const filteredRegions = useMemo(() => {
-		const search = regionSearch.toLowerCase()
-		return search ? AWS_REGIONS.filter((r) => r.includes(search)) : AWS_REGIONS
+		const search = regionSearch.toLowerCase().trim()
+		if (!search) {
+			return AWS_REGIONS
+		}
+		return AWS_REGIONS.filter((r) => r.toLowerCase().includes(search))
 	}, [regionSearch])
 
 	const {
@@ -170,10 +173,18 @@ export const BedrockSetup: React.FC<BedrockSetupProps> = ({ isActive, onComplete
 		}
 	}, [step, authMethod, onCancel])
 
+	const getSelectedRegion = useCallback(() => {
+		if (filteredRegions.length > 0 && regionIndex >= 0 && regionIndex < filteredRegions.length) {
+			return filteredRegions[regionIndex]
+		}
+		// If no matches, use the search term as custom region
+		return regionSearch.trim() || "us-east-1"
+	}, [filteredRegions, regionIndex, regionSearch])
+
 	const finish = useCallback(() => {
 		const config: BedrockConfig = {
 			awsAuthentication: authMethod === "default" ? "credentials" : authMethod,
-			awsRegion: filteredRegions[regionIndex] || "us-east-1",
+			awsRegion: getSelectedRegion(),
 			awsUseCrossRegionInference: crossRegion,
 		}
 		if (authMethod === "profile") {
@@ -184,7 +195,7 @@ export const BedrockSetup: React.FC<BedrockSetupProps> = ({ isActive, onComplete
 			if (sessionToken) config.awsSessionToken = sessionToken
 		}
 		onComplete(config)
-	}, [authMethod, profileName, accessKey, secretKey, sessionToken, filteredRegions, regionIndex, crossRegion, onComplete])
+	}, [authMethod, profileName, accessKey, secretKey, sessionToken, getSelectedRegion, crossRegion, onComplete])
 
 	// Handle input for auth_method, region, and options steps
 	useInput(
@@ -204,11 +215,11 @@ export const BedrockSetup: React.FC<BedrockSetupProps> = ({ isActive, onComplete
 			} else if (step === "region") {
 				if (key.escape) {
 					goBack()
-				} else if (key.upArrow) {
+				} else if (key.upArrow && filteredRegions.length > 0) {
 					setRegionIndex((prev) => (prev > 0 ? prev - 1 : filteredRegions.length - 1))
-				} else if (key.downArrow) {
+				} else if (key.downArrow && filteredRegions.length > 0) {
 					setRegionIndex((prev) => (prev < filteredRegions.length - 1 ? prev + 1 : 0))
-				} else if (key.return && filteredRegions.length > 0) {
+				} else if (key.return && (filteredRegions.length > 0 || regionSearch.trim())) {
 					setStep("options")
 				} else if (key.backspace || key.delete) {
 					setRegionSearch((prev) => prev.slice(0, -1))
@@ -330,7 +341,7 @@ export const BedrockSetup: React.FC<BedrockSetupProps> = ({ isActive, onComplete
 				<Text color="white">AWS Region</Text>
 				<Text> </Text>
 				<Box>
-					<Text color="gray">Search: </Text>
+					<Text color="gray">Search or enter custom region: </Text>
 					<Text color="white">{regionSearch}</Text>
 					<Text inverse> </Text>
 				</Box>
@@ -350,7 +361,6 @@ export const BedrockSetup: React.FC<BedrockSetupProps> = ({ isActive, onComplete
 				{showRegionBottom && (
 					<Text color="gray">... {filteredRegions.length - regionVisibleStart - regionVisibleCount} more below</Text>
 				)}
-				{filteredRegions.length === 0 && <Text color="gray">No regions match "{regionSearch}"</Text>}
 				<Text> </Text>
 				<Text color="gray">Type to search, arrows to navigate, Enter to select, Esc to go back</Text>
 			</Box>

cli/src/components/ChatMessage.markdown.test.tsx

@@ -0,0 +1,53 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { render } from "ink-testing-library"
+import React from "react"
+import { describe, expect, it, vi } from "vitest"
+import { ChatMessage } from "./ChatMessage"
+
+vi.mock("../hooks/useTerminalSize", () => ({
+	useTerminalSize: () => ({
+		columns: 120,
+		rows: 40,
+		resizeKey: 0,
+	}),
+}))
+
+describe("ChatMessage markdown rendering", () => {
+	it("renders basic markdown elements correctly with appropriate styling", () => {
+		const message: ClineMessage = {
+			ts: Date.now(),
+			type: "say",
+			say: "text",
+			text: "# Heading 1\n\nThis is a **bold** and *italic* text with `inline code`.\n\n- List item 1\n- List item 2\n\n> Blockquote\n\n```javascript\nconst x = 1;\n```",
+		}
+
+		const { lastFrame } = render(React.createElement(ChatMessage, { message, mode: "act" }))
+		const frame = lastFrame() || ""
+
+		// Check for heading (bold)
+		// \x1B[1m is the ANSI escape code for bold
+		expect(frame).toMatch(/\x1B\[1mHeading 1\x1B\[22m/)
+
+		// Check for bold text
+		expect(frame).toMatch(/\x1B\[1mbold\x1B\[22m/)
+
+		// Check for italic text
+		// \x1B[3m is the ANSI escape code for italic
+		expect(frame).toMatch(/\x1B\[3mitalic\x1B\[23m/)
+
+		// Check for inline code (no special styling in the current implementation, just text)
+		expect(frame).toContain("inline code")
+
+		// Check for list items (gray bullet)
+		// \x1B[90m is the ANSI escape code for gray
+		expect(frame).toMatch(/\x1B\[90m• \x1B\[39mList item 1/)
+		expect(frame).toMatch(/\x1B\[90m• \x1B\[39mList item 2/)
+
+		// Check for blockquote (gray pipe)
+		expect(frame).toMatch(/\x1B\[90m│ \x1B\[39mBlockquote/)
+
+		// Check for code block (cyan text)
+		// \x1B[36m is the ANSI escape code for cyan
+		expect(frame).toMatch(/\x1B\[36mconst x = 1;\x1B\[39m/)
+	})
+})

cli/src/components/ChatMessage.tsx

@@ -11,6 +11,7 @@ import { COMMAND_OUTPUT_STRING } from "@shared/combineCommandSequences"
 import type { ClineAskUseMcpServer, ClineMessage } from "@shared/ExtensionMessage"
 import { Box, Text } from "ink"
 import Spinner from "ink-spinner"
+import { lexer, type Token, type Tokens } from "marked"
 import React from "react"
 import { COLORS } from "../constants/colors"
 import { useTerminalSize } from "../hooks/useTerminalSize"
@@ -20,13 +21,10 @@ import { DiffView } from "./DiffView"
 import { SubagentMessage } from "./SubagentMessage"
 
 /**
- * Add "(Tab)" hint after "Act mode" mentions.
+ * Add "(Tab)" hint after "Act mode" mentions in plain text.
  * Case-insensitive, avoids double-adding if already present.
- * Matches just "Act mode" without requiring "to " prefix because markdown
- * processing may split "toggle to **Act mode**" into separate text chunks.
  */
 function addActModeHint(text: string, keyPrefix: string): React.ReactNode[] {
-	// Match "Act mode" in various capitalizations, but not if already followed by (Tab)
 	const actModeRegex = /\bact\s+mode\b(?!\s*\(tab\))/gi
 	const parts = text.split(actModeRegex)
 	const matches = text.match(actModeRegex)
@@ -37,9 +35,7 @@ function addActModeHint(text: string, keyPrefix: string): React.ReactNode[] {
 
 	const nodes: React.ReactNode[] = []
 	parts.forEach((part, i) => {
-		if (part) {
-			nodes.push(part)
-		}
+		if (part) nodes.push(part)
 		if (matches[i]) {
 			nodes.push(
 				<React.Fragment key={`${keyPrefix}-act-mode-${i}`}>
@@ -49,72 +45,146 @@ function addActModeHint(text: string, keyPrefix: string): React.ReactNode[] {
 			)
 		}
 	})
-
 	return nodes
 }
 
 /**
- * Render inline markdown: **bold**, *italic*, `code`
- * Also adds "(Tab)" hints after "Act mode" mentions.
- * Returns array of React nodes with appropriate styling
+ * Render an array of marked tokens as Ink React nodes.
+ * This is the entry point for recursive rendering — each token may
+ * contain child tokens (e.g. a paragraph contains inline tokens,
+ * a list contains items, etc.).
  */
-function renderInlineMarkdown(text: string): React.ReactNode[] {
-	const nodes: React.ReactNode[] = []
-	let hintCallIndex = 0
-	const addHintedText = (value: string) => addActModeHint(value, `hint-${hintCallIndex++}`)
-	// Match **bold**, *italic*, or `code` - order matters (** before *)
-	const regex = /(\*\*[^*]+\*\*|\*[^*]+\*|`[^`]+`)/g
-	let lastIndex = 0
-	let match
-
-	while ((match = regex.exec(text)) !== null) {
-		// Add text before match (with Act Mode hint processing)
-		if (match.index > lastIndex) {
-			const beforeText = text.slice(lastIndex, match.index)
-			nodes.push(...addHintedText(beforeText))
-		}
-
-		const fullMatch = match[0]
-		const key = `md-${match.index}`
-
-		if (fullMatch.startsWith("**") && fullMatch.endsWith("**")) {
-			// Bold - also process for Act Mode hints inside bold text
-			const boldContent = fullMatch.slice(2, -2)
-			const hintedContent = addHintedText(boldContent)
-			nodes.push(
-				<Text bold key={key}>
-					{hintedContent}
-				</Text>,
-			)
-		} else if (fullMatch.startsWith("*") && fullMatch.endsWith("*")) {
-			// Italic
-			nodes.push(
-				<Text italic key={key}>
-					{fullMatch.slice(1, -1)}
-				</Text>,
-			)
-		} else if (fullMatch.startsWith("`") && fullMatch.endsWith("`")) {
-			// Inline code
-			nodes.push(<Text key={key}>{fullMatch.slice(1, -1)}</Text>)
-		}
-
-		lastIndex = regex.lastIndex
-	}
-
-	// Add remaining text (with Act Mode hint processing)
-	if (lastIndex < text.length) {
-		nodes.push(...addHintedText(text.slice(lastIndex)))
-	}
-
-	return nodes.length > 0 ? nodes : addHintedText(text)
+function renderTokens(tokens: Token[], color?: string): React.ReactNode[] {
+	return tokens.map((token, i) => renderToken(token, i, color))
 }
 
 /**
- * Render text with inline markdown support
+ * Render a single marked token (block or inline) as an Ink React node.
+ * Handles both block-level tokens (heading, paragraph, list, code, etc.)
+ * and inline tokens (strong, em, codespan, link, text).
+ */
+function renderToken(token: Token, key: number, color?: string): React.ReactNode {
+	switch (token.type) {
+		// --- Block tokens ---
+
+		case "heading": {
+			const { depth, tokens } = token as Tokens.Heading
+			return (
+				<Box key={key} marginY={depth === 1 ? 1 : 0}>
+					<Text bold color={color}>
+						{renderTokens(tokens, color)}
+					</Text>
+				</Box>
+			)
+		}
+
+		case "paragraph":
+			return (
+				<Text color={color} key={key}>
+					{renderTokens((token as Tokens.Paragraph).tokens, color)}
+				</Text>
+			)
+
+		case "code":
+			return (
+				<Box flexDirection="column" key={key} marginY={1}>
+					{(token as Tokens.Code).text.split("\n").map((line, i) => (
+						<Text color="cyan" key={i}>
+							{line || " "}
+						</Text>
+					))}
+				</Box>
+			)
+
+		case "list": {
+			const { ordered, start, items } = token as Tokens.List
+			return (
+				<Box flexDirection="column" key={key}>
+					{items.map((item, i) => (
+						<Box flexDirection="row" key={i}>
+							<Text color="gray">{ordered ? `${Number(start ?? 1) + i}. ` : "• "}</Text>
+							<Box flexDirection="column" flexGrow={1}>
+								{renderTokens(item.tokens, color)}
+							</Box>
+						</Box>
+					))}
+				</Box>
+			)
+		}
+
+		case "blockquote":
+			return (
+				<Box flexDirection="row" key={key}>
+					<Text color="gray">│ </Text>
+					<Box flexDirection="column">{renderTokens((token as Tokens.Blockquote).tokens, color)}</Box>
+				</Box>
+			)
+
+		case "space":
+			return <Text key={key}> </Text>
+
+		// --- Inline tokens ---
+
+		case "strong":
+			return (
+				<Text bold color={color} key={key}>
+					{renderTokens((token as Tokens.Strong).tokens, color)}
+				</Text>
+			)
+
+		case "em":
+			return (
+				<Text color={color} italic key={key}>
+					{renderTokens((token as Tokens.Em).tokens, color)}
+				</Text>
+			)
+
+		case "codespan":
+			return <Text key={key}>{(token as Tokens.Codespan).text}</Text>
+
+		case "link": {
+			const { text, href } = token as Tokens.Link
+			return (
+				<Text color={color} key={key}>
+					{text && text !== href ? `${text} (${href})` : href}
+				</Text>
+			)
+		}
+
+		case "text": {
+			const { text, tokens } = token as Tokens.Text
+			if (tokens?.length) {
+				return (
+					<Text color={color} key={key}>
+						{renderTokens(tokens, color)}
+					</Text>
+				)
+			}
+			return (
+				<Text color={color} key={key}>
+					{addActModeHint(text, `${key}`)}
+				</Text>
+			)
+		}
+
+		// Fallback for any unhandled token type
+		default:
+			return "raw" in token ? (
+				<Text color={color} key={key}>
+					{(token as { raw: string }).raw}
+				</Text>
+			) : null
+	}
+}
+
+/**
+ * Render a markdown string as Ink components.
+ * Uses marked's lexer to parse markdown into tokens, then renders
+ * each token to the appropriate Ink component.
  */
 const MarkdownText: React.FC<{ children: string; color?: string }> = ({ children, color }) => {
-	const nodes = renderInlineMarkdown(children)
-	return <Text color={color}>{nodes}</Text>
+	const tokens = lexer(children)
+	return <Box flexDirection="column">{renderTokens(tokens, color)}</Box>
 }
 
 interface ChatMessageProps {

cli/src/components/ChatView.tsx

@@ -150,6 +150,7 @@ import { HighlightedInput } from "./HighlightedInput"
 import { HistoryPanelContent } from "./HistoryPanelContent"
 import { providerModels } from "./ModelPicker"
 import { SettingsPanelContent } from "./SettingsPanelContent"
+import { SkillsPanelContent } from "./SkillsPanelContent"
 import { SlashCommandMenu } from "./SlashCommandMenu"
 import { ThinkingIndicator } from "./ThinkingIndicator"
 
@@ -412,6 +413,7 @@ export const ChatView: React.FC<ChatViewProps> = ({
 		| { type: "settings"; initialMode?: "model-picker" | "featured-models"; initialModelKey?: "actModelId" | "planModelId" }
 		| { type: "history" }
 		| { type: "help" }
+		| { type: "skills" }
 		| null
 	>(null)
 
@@ -1156,13 +1158,21 @@ export const ChatView: React.FC<ChatViewProps> = ({
 						setSlashMenuDismissed(true)
 						return
 					}
+					if (cmd.name === "skills") {
+						setActivePanel({ type: "skills" })
+						setTextInput("")
+						setCursorPos(0)
+						setSelectedSlashIndex(0)
+						setSlashMenuDismissed(true)
+						return
+					}
 					if (cmd.name === "clear") {
 						clearViewAndResetTask()
 						setSelectedSlashIndex(0)
 						setSlashMenuDismissed(true)
 						return
 					}
-					if (cmd.name === "exit") {
+					if (cmd.name === "exit" || cmd.name === "q") {
 						handleExit()
 						return
 					}
@@ -1545,6 +1555,19 @@ export const ChatView: React.FC<ChatViewProps> = ({
 				{/* Help panel */}
 				{activePanel?.type === "help" && <HelpPanelContent onClose={() => setActivePanel(null)} />}
 
+				{/* Skills panel */}
+				{activePanel?.type === "skills" && ctrl && (
+					<SkillsPanelContent
+						controller={ctrl}
+						onClose={() => setActivePanel(null)}
+						onUseSkill={(skillPath) => {
+							setActivePanel(null)
+							setTextInput(`@${skillPath} `)
+							setCursorPos(skillPath.length + 2)
+						}}
+					/>
+				)}
+
 				{/* Slash command menu - below input (takes priority over file menu) */}
 				{showSlashMenu && !activePanel && (
 					<Box paddingLeft={1} paddingRight={1}>

cli/src/components/FeaturedModelPicker.tsx

@@ -7,13 +7,14 @@
 import { Box, Text } from "ink"
 import React from "react"
 import { COLORS } from "../constants/colors"
-import { type FeaturedModel, getAllFeaturedModels } from "../constants/featured-models"
+import type { FeaturedModel } from "../constants/featured-models"
 
 interface FeaturedModelPickerProps {
 	selectedIndex: number
 	title?: string
 	showBrowseAll?: boolean
 	helpText?: string
+	featuredModels: FeaturedModel[]
 }
 
 export const FeaturedModelPicker: React.FC<FeaturedModelPickerProps> = ({
@@ -21,8 +22,9 @@ export const FeaturedModelPicker: React.FC<FeaturedModelPickerProps> = ({
 	title,
 	showBrowseAll = true,
 	helpText = "Arrows to navigate, Enter to select",
+	featuredModels,
 }) => {
-	const featuredModels = getAllFeaturedModels()
+	const models = featuredModels
 
 	return (
 		<Box flexDirection="column">
@@ -35,11 +37,11 @@ export const FeaturedModelPicker: React.FC<FeaturedModelPickerProps> = ({
 				</Text>
 			)}
 
-			{featuredModels.map((model, i) => {
+			{models.map((model, i) => {
 				const isSelected = i === selectedIndex
 
 				return (
-					<Box flexDirection="column" key={model.id} marginBottom={1}>
+					<Box flexDirection="column" key={`${model.id}-${model.labels[0] || "default"}`} marginBottom={1}>
 						<Box>
 							<Text color={isSelected ? COLORS.primaryBlue : undefined}>{isSelected ? "❯ " : "  "}</Text>
 							<Text bold color={isSelected ? COLORS.primaryBlue : "white"}>
@@ -64,8 +66,8 @@ export const FeaturedModelPicker: React.FC<FeaturedModelPickerProps> = ({
 
 			{showBrowseAll && (
 				<Box>
-					<Text color={selectedIndex === featuredModels.length ? COLORS.primaryBlue : "white"}>
-						{selectedIndex === featuredModels.length ? "❯ " : "  "}
+					<Text color={selectedIndex === models.length ? COLORS.primaryBlue : "white"}>
+						{selectedIndex === models.length ? "❯ " : "  "}
 						Browse all models...
 					</Text>
 				</Box>
@@ -81,24 +83,21 @@ export const FeaturedModelPicker: React.FC<FeaturedModelPickerProps> = ({
  * Get the maximum valid index for the featured model picker
  * (includes "Browse all" option if showBrowseAll is true)
  */
-export function getFeaturedModelMaxIndex(showBrowseAll: boolean = true): number {
-	const featuredModels = getAllFeaturedModels()
+export function getFeaturedModelMaxIndex(featuredModels: FeaturedModel[], showBrowseAll = true): number {
 	return showBrowseAll ? featuredModels.length : featuredModels.length - 1
 }
 
 /**
  * Check if the selected index is the "Browse all" option
  */
-export function isBrowseAllSelected(selectedIndex: number): boolean {
-	const featuredModels = getAllFeaturedModels()
+export function isBrowseAllSelected(selectedIndex: number, featuredModels: FeaturedModel[]): boolean {
 	return selectedIndex === featuredModels.length
 }
 
 /**
  * Get the featured model at the given index, or null if "Browse all" is selected
  */
-export function getFeaturedModelAtIndex(index: number): FeaturedModel | null {
-	const featuredModels = getAllFeaturedModels()
+export function getFeaturedModelAtIndex(index: number, featuredModels: FeaturedModel[]): FeaturedModel | null {
 	if (index >= 0 && index < featuredModels.length) {
 		return featuredModels[index]
 	}

cli/src/components/HelpPanelContent.tsx

@@ -88,6 +88,10 @@ export const HelpPanelContent: React.FC<HelpPanelContentProps> = ({ onClose }) =
 						{"  "}
 						<Text color="white">/clear</Text> - Start a fresh task
 					</Text>
+					<Text>
+						{"  "}
+						<Text color="white">/q</Text> - Quit Cline
+					</Text>
 				</Box>
 
 				<Text>

cli/src/components/ModelPicker.tsx

@@ -71,6 +71,9 @@ import { COLORS } from "../constants/colors"
 import { getOpenRouterDefaultModelId, usesOpenRouterModels } from "../utils/openrouter-models"
 import { SearchableList, SearchableListItem } from "./SearchableList"
 
+// Special ID used to indicate the user wants to enter a custom model ID / ARN
+export const CUSTOM_MODEL_ID = "__custom__"
+
 // Map providers to their static model lists and defaults
 export const providerModels: Record<string, { models: Record<string, unknown>; defaultId: string }> = {
 	anthropic: { models: anthropicModels, defaultId: anthropicDefaultModelId },
@@ -169,12 +172,23 @@ export const ModelPicker: React.FC<ModelPickerProps> = ({ provider, controller,
 		return getModelList(provider)
 	}, [provider, asyncModels])
 
+	// Providers that support custom model IDs (e.g., Bedrock Application Inference Profiles)
+	const supportsCustomModel = provider === "bedrock"
+
 	const items: SearchableListItem[] = useMemo(() => {
-		return modelList.map((modelId) => ({
+		const list = modelList.map((modelId) => ({
 			id: modelId,
 			label: modelId,
 		}))
-	}, [modelList])
+		// Add "Custom" option at the end for providers that support it
+		if (supportsCustomModel) {
+			list.push({
+				id: CUSTOM_MODEL_ID,
+				label: "Custom (ARN / Inference Profile)",
+			})
+		}
+		return list
+	}, [modelList, supportsCustomModel])
 
 	// For providers without a model picker, render nothing
 	if (!hasModelPicker(provider)) {

cli/src/components/QuitCommand.test.tsx

@@ -0,0 +1,112 @@
+import { render } from "ink-testing-library"
+// biome-ignore lint/correctness/noUnusedImports: React must be in scope for JSX in this test file.
+import React from "react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+// Mock ink's useApp
+const mockExit = vi.fn()
+vi.mock("ink", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("ink")>()
+	return {
+		...actual,
+		useApp: () => ({ exit: mockExit }),
+	}
+})
+
+// Mock child_process
+vi.mock("child_process", () => ({
+	execSync: vi.fn().mockReturnValue(""),
+	exec: vi.fn(),
+}))
+
+// Mock dependencies
+vi.mock("@/core/controller/slash/getAvailableSlashCommands", () => ({
+	getAvailableSlashCommands: vi.fn().mockResolvedValue({ commands: [] }),
+}))
+
+vi.mock("@/core/storage/StateManager", () => ({
+	StateManager: {
+		get: () => ({
+			getGlobalSettingsKey: vi.fn().mockReturnValue("act"),
+			getGlobalStateKey: vi.fn().mockReturnValue([]),
+			getApiConfiguration: vi.fn().mockReturnValue({}),
+		}),
+	},
+}))
+
+vi.mock("@/services/telemetry", () => ({
+	telemetryService: {
+		captureHostEvent: vi.fn(),
+	},
+}))
+
+vi.mock("@shared/services/Session", () => ({
+	Session: {
+		get: () => ({
+			getStats: vi.fn().mockReturnValue({}),
+		}),
+	},
+}))
+
+vi.mock("../context/TaskContext", () => ({
+	useTaskContext: () => ({
+		controller: {},
+		clearState: vi.fn(),
+	}),
+	useTaskState: () => ({
+		clineMessages: [],
+	}),
+}))
+
+vi.mock("../hooks/useStateSubscriber", () => ({
+	useIsSpinnerActive: () => ({ isActive: false, startTime: 0 }),
+}))
+
+import { ChatView } from "./ChatView"
+
+// Helper to wait for async state updates
+const delay = (ms = 60) => new Promise((resolve) => setTimeout(resolve, ms))
+
+describe("Quit Command (/q and /exit)", () => {
+	const mockOnExit = vi.fn()
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("should exit the application when /q is selected from slash menu", async () => {
+		const { stdin } = render(<ChatView onExit={mockOnExit} />)
+		await delay()
+
+		// Type /q
+		stdin.write("/q")
+		await delay()
+
+		// Press Enter
+		stdin.write("\r")
+
+		// handleExit has a 150ms timeout
+		await delay(200)
+
+		expect(mockExit).toHaveBeenCalled()
+		expect(mockOnExit).toHaveBeenCalled()
+	})
+
+	it("should exit the application when /exit is selected from slash menu", async () => {
+		const { stdin } = render(<ChatView onExit={mockOnExit} />)
+		await delay()
+
+		// Type /exit
+		stdin.write("/exit")
+		await delay()
+
+		// Press Enter
+		stdin.write("\r")
+
+		// handleExit has a 150ms timeout
+		await delay(200)
+
+		expect(mockExit).toHaveBeenCalled()
+		expect(mockOnExit).toHaveBeenCalled()
+	})
+})

cli/src/components/SettingsPanelContent.tsx

@@ -25,10 +25,12 @@ import { supportsReasoningEffortForModel } from "@/utils/model-utils"
 import { version as CLI_VERSION } from "../../package.json"
 import { COLORS } from "../constants/colors"
 import { useStdinContext } from "../context/StdinContext"
+import { useClineFeaturedModels } from "../hooks/useClineFeaturedModels"
 import { useOcaAuth } from "../hooks/useOcaAuth"
 import { isMouseEscapeSequence } from "../utils/input"
 import { applyBedrockConfig, applyProviderConfig } from "../utils/provider-config"
 import { ApiKeyInput } from "./ApiKeyInput"
+import { BedrockCustomModelFlow } from "./BedrockCustomModelFlow"
 import { type BedrockConfig, BedrockSetup } from "./BedrockSetup"
 import { Checkbox } from "./Checkbox"
 import {
@@ -38,7 +40,7 @@ import {
 	isBrowseAllSelected,
 } from "./FeaturedModelPicker"
 import { LanguagePicker } from "./LanguagePicker"
-import { hasModelPicker, ModelPicker } from "./ModelPicker"
+import { CUSTOM_MODEL_ID, hasModelPicker, ModelPicker } from "./ModelPicker"
 import { OcaEmployeeCheck } from "./OcaEmployeeCheck"
 import { OrganizationPicker } from "./OrganizationPicker"
 import { Panel, PanelTab } from "./Panel"
@@ -160,6 +162,7 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 	)
 	const [isPickingFeaturedModel, setIsPickingFeaturedModel] = useState(initialMode === "featured-models")
 	const [featuredModelIndex, setFeaturedModelIndex] = useState(0)
+	const featuredModels = useClineFeaturedModels()
 	const [isPickingProvider, setIsPickingProvider] = useState(false)
 	const [isPickingLanguage, setIsPickingLanguage] = useState(false)
 	const [isEnteringApiKey, setIsEnteringApiKey] = useState(false)
@@ -171,6 +174,9 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 	const [apiKeyValue, setApiKeyValue] = useState("")
 	const [editValue, setEditValue] = useState("")
 
+	// Bedrock custom ARN flow state
+	const [isBedrockCustomFlow, setIsBedrockCustomFlow] = useState(false)
+
 	// Settings state - single object for feature toggles
 	const [features, setFeatures] = useState<Record<FeatureKey, boolean>>(() => {
 		const initial: Record<string, boolean> = {}
@@ -944,10 +950,56 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 		setReasoningEffortForMode,
 	])
 
+	// Handle completion of the Bedrock custom ARN flow (ARN + base model selected)
+	const handleBedrockCustomFlowComplete = useCallback(
+		async (arn: string, baseModelId: string) => {
+			if (!pickingModelKey) return
+			const apiConfig = stateManager.getApiConfiguration()
+
+			// Build a minimal BedrockConfig from current state for applyBedrockConfig
+			const bedrockConfig: BedrockConfig = {
+				awsRegion: apiConfig.awsRegion ?? "us-east-1",
+				awsAuthentication: apiConfig.awsUseProfile ? "profile" : "credentials",
+				awsUseCrossRegionInference: Boolean(apiConfig.awsUseCrossRegionInference),
+			}
+
+			await applyBedrockConfig({
+				bedrockConfig,
+				modelId: arn,
+				customModelBaseId: baseModelId,
+				controller,
+			})
+
+			// Flush pending state to ensure everything is persisted
+			await stateManager.flushPendingState()
+
+			// Rebuild API handler if there's an active task
+			rebuildTaskApi()
+
+			refreshModelIds()
+			setIsBedrockCustomFlow(false)
+			setPickingModelKey(null)
+
+			// If opened from /models command, close the entire settings panel
+			if (initialMode) {
+				onClose()
+			}
+		},
+		[pickingModelKey, stateManager, controller, rebuildTaskApi, refreshModelIds, initialMode, onClose],
+	)
+
 	// Handle model selection from picker
 	const handleModelSelect = useCallback(
 		async (modelId: string) => {
 			if (!pickingModelKey) return
+
+			// Intercept "Custom" selection for Bedrock — redirect to custom ARN input flow
+			if (modelId === CUSTOM_MODEL_ID && provider === "bedrock") {
+				setIsPickingModel(false)
+				setIsBedrockCustomFlow(true)
+				return
+			}
+
 			const apiConfig = stateManager.getApiConfiguration()
 			const actProvider = apiConfig.actModeApiProvider
 			const planProvider = apiConfig.planModeApiProvider || actProvider
@@ -1008,7 +1060,7 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 				onClose()
 			}
 		},
-		[pickingModelKey, separateModels, stateManager, controller, refreshModelIds, initialMode, onClose],
+		[pickingModelKey, separateModels, stateManager, controller, provider, refreshModelIds, initialMode, onClose],
 	)
 
 	// Handle language selection from picker
@@ -1242,7 +1294,7 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 
 			// Featured model picker mode (Cline provider)
 			if (isPickingFeaturedModel) {
-				const maxIndex = getFeaturedModelMaxIndex()
+				const maxIndex = getFeaturedModelMaxIndex(featuredModels)
 
 				if (key.escape) {
 					setIsPickingFeaturedModel(false)
@@ -1256,12 +1308,12 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 				} else if (key.downArrow) {
 					setFeaturedModelIndex((prev) => (prev < maxIndex ? prev + 1 : 0))
 				} else if (key.return) {
-					if (isBrowseAllSelected(featuredModelIndex)) {
+					if (isBrowseAllSelected(featuredModelIndex, featuredModels)) {
 						// Switch to full ModelPicker
 						setIsPickingFeaturedModel(false)
 						setIsPickingModel(true)
 					} else {
-						const selectedModel = getFeaturedModelAtIndex(featuredModelIndex)
+						const selectedModel = getFeaturedModelAtIndex(featuredModelIndex, featuredModels)
 						if (selectedModel && pickingModelKey) {
 							handleModelSelect(selectedModel.id)
 							setIsPickingFeaturedModel(false)
@@ -1332,6 +1384,11 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 				return
 			}
 
+			// Bedrock custom flow - input handled by BedrockCustomModelFlow component
+			if (isBedrockCustomFlow) {
+				return
+			}
+
 			if (isEditing) {
 				if (key.escape) {
 					setIsEditing(false)
@@ -1467,6 +1524,7 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 			const label = pickingModelKey === "actModelId" ? "Model ID (Act)" : "Model ID (Plan)"
 			return (
 				<FeaturedModelPicker
+					featuredModels={featuredModels}
 					helpText="Arrows to navigate, Enter to select, Esc to cancel"
 					selectedIndex={featuredModelIndex}
 					title={`Select: ${label}`}
@@ -1584,6 +1642,20 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 			)
 		}
 
+		// Bedrock custom model flow (ARN input + base model selection)
+		if (isBedrockCustomFlow) {
+			return (
+				<BedrockCustomModelFlow
+					isActive={isBedrockCustomFlow}
+					onCancel={() => {
+						setIsBedrockCustomFlow(false)
+						setIsPickingModel(true)
+					}}
+					onComplete={handleBedrockCustomFlowComplete}
+				/>
+			)
+		}
+
 		// Account tab - loading state
 		if (currentTab === "account" && isAccountLoading) {
 			return (
@@ -1748,6 +1820,7 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 		isWaitingForClineAuth ||
 		isShowingOcaEmployeeCheck ||
 		isWaitingForOcaAuth ||
+		isBedrockCustomFlow ||
 		isEditing
 
 	return (

cli/src/components/SkillsPanelContent.test.tsx

@@ -0,0 +1,230 @@
+/**
+ * Tests for SkillsPanelContent component
+ *
+ * Tests keyboard interactions and callbacks.
+ * Rendering tests are limited due to ink-testing-library constraints with nested components.
+ */
+
+import { render } from "ink-testing-library"
+// biome-ignore lint/correctness/noUnusedImports: React must be in scope for JSX in this test file.
+import React from "react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+// Mock refreshSkills
+const mockRefreshSkills = vi.fn()
+vi.mock("@/core/controller/file/refreshSkills", () => ({
+	refreshSkills: () => mockRefreshSkills(),
+}))
+
+// Mock toggleSkill
+const mockToggleSkill = vi.fn()
+vi.mock("@/core/controller/file/toggleSkill", () => ({
+	toggleSkill: (...args: unknown[]) => mockToggleSkill(...args),
+}))
+
+// Mock child_process exec
+const mockExec = vi.fn()
+vi.mock("node:child_process", () => ({
+	exec: (...args: unknown[]) => mockExec(...args),
+}))
+
+// Mock StdinContext
+vi.mock("../context/StdinContext", () => ({
+	useStdinContext: () => ({ isRawModeSupported: true }),
+}))
+
+import { SkillsPanelContent } from "./SkillsPanelContent"
+
+// Helper to wait for async state updates
+const delay = (ms = 60) => new Promise((resolve) => setTimeout(resolve, ms))
+
+describe("SkillsPanelContent", () => {
+	const mockController = {} as any
+	const mockOnClose = vi.fn()
+	const mockOnUseSkill = vi.fn()
+
+	const defaultProps = {
+		controller: mockController,
+		onClose: mockOnClose,
+		onUseSkill: mockOnUseSkill,
+	}
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+		mockRefreshSkills.mockResolvedValue({
+			globalSkills: [],
+			localSkills: [],
+		})
+	})
+
+	describe("keyboard interactions", () => {
+		it("should call onClose when Escape is pressed", async () => {
+			mockRefreshSkills.mockResolvedValue({
+				globalSkills: [],
+				localSkills: [],
+			})
+
+			const { stdin } = render(<SkillsPanelContent {...defaultProps} />)
+			await delay()
+
+			stdin.write("\x1B") // Escape
+			await delay()
+
+			expect(mockOnClose).toHaveBeenCalled()
+		})
+
+		it("should call onUseSkill with skill path when Enter is pressed on a skill", async () => {
+			mockRefreshSkills.mockResolvedValue({
+				globalSkills: [{ name: "test-skill", description: "Test", path: "/test/path/SKILL.md", enabled: true }],
+				localSkills: [],
+			})
+
+			const { stdin } = render(<SkillsPanelContent {...defaultProps} />)
+			await delay()
+
+			stdin.write("\r") // Enter
+			await delay()
+
+			expect(mockOnUseSkill).toHaveBeenCalledWith("/test/path/SKILL.md")
+		})
+
+		it("should call toggleSkill when Space is pressed on a skill", async () => {
+			mockRefreshSkills.mockResolvedValue({
+				globalSkills: [{ name: "test-skill", description: "Test", path: "/test/path/SKILL.md", enabled: true }],
+				localSkills: [],
+			})
+
+			const { stdin } = render(<SkillsPanelContent {...defaultProps} />)
+			await delay()
+
+			stdin.write(" ") // Space
+			await delay()
+
+			expect(mockToggleSkill).toHaveBeenCalledWith(
+				mockController,
+				expect.objectContaining({
+					skillPath: "/test/path/SKILL.md",
+					isGlobal: true,
+					enabled: false, // toggled from true to false
+				}),
+			)
+		})
+
+		it("should open marketplace URL when Enter is pressed on marketplace item", async () => {
+			mockRefreshSkills.mockResolvedValue({
+				globalSkills: [{ name: "skill", description: "desc", path: "/path", enabled: true }],
+				localSkills: [],
+			})
+
+			const { stdin } = render(<SkillsPanelContent {...defaultProps} />)
+			await delay()
+
+			// Navigate down to marketplace (past the one skill)
+			stdin.write("\x1B[B") // Down arrow
+			await delay()
+
+			stdin.write("\r") // Enter
+			await delay()
+
+			// Should have called exec with open command
+			expect(mockExec).toHaveBeenCalled()
+			const execCall = mockExec.mock.calls[0][0]
+			expect(execCall).toContain("https://skills.sh/")
+		})
+
+		it("should navigate through skills with arrow keys", async () => {
+			mockRefreshSkills.mockResolvedValue({
+				globalSkills: [
+					{ name: "skill-1", description: "First", path: "/path1", enabled: true },
+					{ name: "skill-2", description: "Second", path: "/path2", enabled: true },
+				],
+				localSkills: [],
+			})
+
+			const { stdin } = render(<SkillsPanelContent {...defaultProps} />)
+			await delay()
+
+			// Navigate down
+			stdin.write("\x1B[B") // Down arrow
+			await delay()
+
+			// Press Enter - should use second skill
+			stdin.write("\r")
+			await delay()
+
+			expect(mockOnUseSkill).toHaveBeenCalledWith("/path2")
+		})
+
+		it("should navigate with vim keys (j/k)", async () => {
+			mockRefreshSkills.mockResolvedValue({
+				globalSkills: [
+					{ name: "skill-1", description: "First", path: "/path1", enabled: true },
+					{ name: "skill-2", description: "Second", path: "/path2", enabled: true },
+				],
+				localSkills: [],
+			})
+
+			const { stdin } = render(<SkillsPanelContent {...defaultProps} />)
+			await delay()
+
+			// Navigate down with j
+			stdin.write("j")
+			await delay()
+
+			// Press Enter - should use second skill
+			stdin.write("\r")
+			await delay()
+
+			expect(mockOnUseSkill).toHaveBeenCalledWith("/path2")
+		})
+
+		it("should revert optimistic toggle on failure", async () => {
+			mockRefreshSkills.mockResolvedValue({
+				globalSkills: [{ name: "test-skill", description: "Test", path: "/test/path/SKILL.md", enabled: true }],
+				localSkills: [],
+			})
+			mockToggleSkill.mockRejectedValueOnce(new Error("toggle failed"))
+
+			const { stdin, lastFrame } = render(<SkillsPanelContent {...defaultProps} />)
+			await delay()
+
+			stdin.write(" ") // Space to toggle
+			await delay(100)
+
+			// toggleSkill was called with enabled: false (toggled from true)
+			expect(mockToggleSkill).toHaveBeenCalledWith(mockController, expect.objectContaining({ enabled: false }))
+			const frame = lastFrame() || ""
+			expect(frame).toContain("● test-skill")
+			expect(frame).not.toContain("○ test-skill")
+		})
+
+		it("should wrap navigation at list boundaries", async () => {
+			mockRefreshSkills.mockResolvedValue({
+				globalSkills: [{ name: "only-skill", description: "Only", path: "/only", enabled: true }],
+				localSkills: [],
+			})
+
+			const { stdin } = render(<SkillsPanelContent {...defaultProps} />)
+			await delay()
+
+			// Navigate up from first item (should wrap to last - marketplace)
+			stdin.write("\x1B[A") // Up arrow
+			await delay()
+
+			stdin.write("\r") // Enter
+			await delay()
+
+			// Should have opened marketplace (wrapped to last item)
+			expect(mockExec).toHaveBeenCalled()
+		})
+	})
+
+	describe("skill loading", () => {
+		it("should call refreshSkills on mount", async () => {
+			render(<SkillsPanelContent {...defaultProps} />)
+			await delay()
+
+			expect(mockRefreshSkills).toHaveBeenCalled()
+		})
+	})
+})

cli/src/components/SkillsPanelContent.tsx

@@ -0,0 +1,257 @@
+/**
+ * Skills panel content for inline display in ChatView
+ * Shows installed skills with toggle and use functionality
+ */
+
+import { exec } from "node:child_process"
+import os from "node:os"
+import { Box, Text, useInput } from "ink"
+import React, { useCallback, useEffect, useMemo, useState } from "react"
+import type { Controller } from "@/core/controller"
+import { refreshSkills } from "@/core/controller/file/refreshSkills"
+import { toggleSkill } from "@/core/controller/file/toggleSkill"
+import { COLORS } from "../constants/colors"
+import { useStdinContext } from "../context/StdinContext"
+import { isMouseEscapeSequence } from "../utils/input"
+import { Panel } from "./Panel"
+
+const SKILLS_MARKETPLACE_URL = "https://skills.sh/"
+
+interface SkillInfo {
+	name: string
+	description: string
+	path: string
+	enabled: boolean
+}
+
+interface SkillsPanelContentProps {
+	controller: Controller
+	onClose: () => void
+	onUseSkill: (skillPath: string) => void
+}
+
+const MAX_VISIBLE = 8
+
+export const SkillsPanelContent: React.FC<SkillsPanelContentProps> = ({ controller, onClose, onUseSkill }) => {
+	const { isRawModeSupported } = useStdinContext()
+	const [globalSkills, setGlobalSkills] = useState<SkillInfo[]>([])
+	const [localSkills, setLocalSkills] = useState<SkillInfo[]>([])
+	const [selectedIndex, setSelectedIndex] = useState(0)
+	const [isLoading, setIsLoading] = useState(true)
+
+	// Load skills on mount
+	useEffect(() => {
+		const loadSkills = async () => {
+			try {
+				const skillsData = await refreshSkills(controller)
+				setGlobalSkills(skillsData.globalSkills || [])
+				setLocalSkills(skillsData.localSkills || [])
+			} catch (_error) {
+				// Skills loading failed, show empty state
+			} finally {
+				setIsLoading(false)
+			}
+		}
+		loadSkills()
+	}, [controller])
+
+	// Build flat list of skills with source info (global first, then local, alphabetical within each)
+	const skillEntries = useMemo(() => {
+		const entries: { skill: SkillInfo; isGlobal: boolean }[] = []
+		globalSkills.forEach((skill) => entries.push({ skill, isGlobal: true }))
+		localSkills.forEach((skill) => entries.push({ skill, isGlobal: false }))
+		return entries.sort((a, b) => {
+			if (a.isGlobal !== b.isGlobal) return a.isGlobal ? -1 : 1
+			return a.skill.name.localeCompare(b.skill.name)
+		})
+	}, [globalSkills, localSkills])
+
+	// Handle toggle
+	const handleToggle = useCallback(async () => {
+		const entry = skillEntries[selectedIndex]
+		if (!entry) return
+
+		const newEnabled = !entry.skill.enabled
+		const setter = entry.isGlobal ? setGlobalSkills : setLocalSkills
+		const update = (enabled: boolean) =>
+			setter((prev) => prev.map((s) => (s.path === entry.skill.path ? { ...s, enabled } : s)))
+
+		// Optimistic update
+		update(newEnabled)
+
+		try {
+			await toggleSkill(controller, {
+				metadata: undefined,
+				skillPath: entry.skill.path,
+				isGlobal: entry.isGlobal,
+				enabled: newEnabled,
+			})
+		} catch {
+			// Revert on failure
+			update(!newEnabled)
+		}
+	}, [controller, skillEntries, selectedIndex])
+
+	// Handle use skill (insert @ mention)
+	const handleUse = useCallback(() => {
+		const entry = skillEntries[selectedIndex]
+		if (!entry) return
+		onUseSkill(entry.skill.path)
+	}, [skillEntries, selectedIndex, onUseSkill])
+
+	// Handle opening the marketplace URL
+	const openMarketplace = useCallback(() => {
+		const platform = os.platform()
+		let command: string
+		if (platform === "darwin") {
+			command = `open "${SKILLS_MARKETPLACE_URL}"`
+		} else if (platform === "win32") {
+			command = `start "${SKILLS_MARKETPLACE_URL}"`
+		} else {
+			command = `xdg-open "${SKILLS_MARKETPLACE_URL}"`
+		}
+		exec(command, (err) => {
+			if (err) {
+				// Fallback: show URL in terminal if browser open fails
+				console.error(`Visit: ${SKILLS_MARKETPLACE_URL}`)
+			}
+		})
+	}, [])
+
+	// Total items = skills + 1 for marketplace link
+	const totalItems = skillEntries.length + 1
+	const isMarketplaceSelected = selectedIndex === skillEntries.length
+
+	useInput(
+		(input, key) => {
+			if (isMouseEscapeSequence(input)) {
+				return
+			}
+			if (key.escape) {
+				onClose()
+				return
+			}
+
+			// Navigation
+			if (key.upArrow || input === "k") {
+				setSelectedIndex((i) => (i > 0 ? i - 1 : totalItems - 1))
+				return
+			}
+			if (key.downArrow || input === "j") {
+				setSelectedIndex((i) => (i < totalItems - 1 ? i + 1 : 0))
+				return
+			}
+
+			// Actions
+			if (key.return) {
+				if (isMarketplaceSelected) {
+					openMarketplace()
+				} else {
+					handleUse()
+				}
+				return
+			}
+			if (input === " " && !isMarketplaceSelected) {
+				handleToggle()
+				return
+			}
+		},
+		{ isActive: isRawModeSupported },
+	)
+
+	// Scrolling window (includes marketplace row)
+	const halfVisible = Math.floor(MAX_VISIBLE / 2)
+	const startIndex = Math.max(0, Math.min(selectedIndex - halfVisible, totalItems - MAX_VISIBLE))
+
+	if (isLoading) {
+		return (
+			<Panel label="Skills">
+				<Text color="gray">Loading skills...</Text>
+			</Panel>
+		)
+	}
+
+	// Check if marketplace row is in visible window
+	const marketplaceIndex = skillEntries.length
+	const showMarketplace = marketplaceIndex >= startIndex && marketplaceIndex < startIndex + MAX_VISIBLE
+
+	return (
+		<Panel label="Skills">
+			<Box flexDirection="column" gap={1}>
+				{skillEntries.length === 0 ? (
+					<Box flexDirection="column" gap={1}>
+						<Text color="gray">No skills installed.</Text>
+						<Text>
+							Install skills with: <Text color="white">npx skills add owner/repo</Text>
+						</Text>
+					</Box>
+				) : (
+					<Box flexDirection="column">
+						{skillEntries
+							.slice(startIndex, Math.min(startIndex + MAX_VISIBLE, skillEntries.length))
+							.map((entry, idx) => {
+								const actualIndex = startIndex + idx
+								const prevEntry = skillEntries[actualIndex - 1]
+								const showHeader = actualIndex === 0 || (prevEntry && prevEntry.isGlobal !== entry.isGlobal)
+
+								return (
+									<React.Fragment key={entry.skill.path}>
+										{showHeader && (
+											<Box marginTop={actualIndex > 0 ? 1 : 0}>
+												<Text bold color="gray">
+													{entry.isGlobal ? "Global Skills:" : "Workspace Skills:"}
+												</Text>
+											</Box>
+										)}
+										<SkillRow isSelected={actualIndex === selectedIndex} skill={entry.skill} />
+									</React.Fragment>
+								)
+							})}
+					</Box>
+				)}
+
+				{/* Marketplace link - selectable */}
+				{showMarketplace && (
+					<Box marginTop={1}>
+						<Text color={isMarketplaceSelected ? "cyan" : undefined}>
+							{isMarketplaceSelected ? "❯ " : "  "}
+							<Text color={COLORS.primaryBlue}>Browse more skills at https://skills.sh/</Text>
+						</Text>
+					</Box>
+				)}
+
+				{/* Help text */}
+				<Box marginTop={1}>
+					<Text color="gray">
+						↑/↓ Navigate • Enter {isMarketplaceSelected ? "Open" : "Use"}
+						{!isMarketplaceSelected && " • Space Toggle"}
+					</Text>
+				</Box>
+			</Box>
+		</Panel>
+	)
+}
+
+const SkillRow: React.FC<{ skill: SkillInfo; isSelected: boolean }> = ({ skill, isSelected }) => {
+	return (
+		<Box flexDirection="column">
+			<Box>
+				<Text color={isSelected ? "cyan" : undefined}>
+					{isSelected ? "❯ " : "  "}
+					<Text color={skill.enabled ? "green" : "red"}>{skill.enabled ? "●" : "○"}</Text>
+					<Text> </Text>
+					<Text bold color="white">
+						{skill.name}
+					</Text>
+				</Text>
+			</Box>
+			{skill.description && (
+				<Box marginLeft={4}>
+					<Text color="gray">
+						{skill.description.length > 60 ? skill.description.slice(0, 57) + "..." : skill.description}
+					</Text>
+				</Box>
+			)}
+		</Box>
+	)
+}

cli/src/constants/featured-models.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest"
+import { getAllFeaturedModels, mapRecommendedModelsToFeaturedModels } from "./featured-models"
+
+describe("featured models", () => {
+	it("includes display names for all featured models", () => {
+		const models = getAllFeaturedModels()
+
+		for (const model of models) {
+			expect(model.name).toBeTruthy()
+		}
+	})
+
+	it("fills free model metadata from fallback when upstream payload is sparse", () => {
+		const models = mapRecommendedModelsToFeaturedModels({
+			recommended: [],
+			free: [{ id: "trinity-large-preview:free", name: "trinity-large-preview:free", description: "", tags: [] }],
+		})
+
+		expect(models.free[0]?.name).toBe("Arcee AI Trinity Large Preview")
+		expect(models.free[0]?.description).toBe("Arcee AI's advanced large preview model in the Trinity series")
+		expect(models.free[0]?.labels).toContain("FREE")
+	})
+})

cli/src/constants/featured-models.ts

@@ -2,6 +2,7 @@
  * Featured models shown in the Cline model picker during onboarding
  * These are curated models that work well with Cline
  */
+import { CLINE_RECOMMENDED_MODELS_FALLBACK } from "@shared/cline/recommended-models"
 
 export interface FeaturedModel {
 	id: string
@@ -10,46 +11,81 @@ export interface FeaturedModel {
 	labels: string[]
 }
 
-export const FEATURED_MODELS = {
-	recommended: [
-		{
-			id: "anthropic/claude-opus-4.6",
-			name: "Claude Opus 4.6",
-			description: "State-of-the-art for complex coding",
-			labels: ["BEST"],
-		},
-		{
-			id: "openai/gpt-5.2-codex",
-			name: "GPT 5.2 Codex",
-			description: "OpenAI's latest with strong coding abilities",
-			labels: ["NEW"],
-		},
-		{
-			id: "google/gemini-3-pro-preview",
-			name: "Gemini 3 Pro",
-			description: "1M context window for large codebases",
-			labels: ["TRENDING"],
-		},
-	] as FeaturedModel[],
-	free: [
-		{
-			id: "minimax/minimax-m2.5",
-			description: "MiniMax-M2.5 is a lightweight, state-of-the-art LLM optimized for coding and agentic workflows",
-			labels: ["FREE"],
-		},
-		{
-			id: "kwaipilot/kat-coder-pro",
-			description: "KwaiKAT's most advanced agentic coding model in the KAT-Coder series",
-			labels: ["FREE"],
-		},
-		{
-			id: "arcee-ai/trinity-large-preview:free",
-			description: "Arcee AI's advanced large preview model in the Trinity series",
-			labels: ["FREE"],
-		},
-	] as FeaturedModel[],
+type RecommendedModelLike = {
+	id: string
+	name: string
+	description: string
+	tags: string[]
 }
 
-export function getAllFeaturedModels(): FeaturedModel[] {
-	return [...FEATURED_MODELS.recommended, ...FEATURED_MODELS.free]
+export interface FeaturedModelsByTier {
+	recommended: FeaturedModel[]
+	free: FeaturedModel[]
+}
+
+interface RecommendedModelsByTier {
+	recommended: RecommendedModelLike[]
+	free: RecommendedModelLike[]
+}
+
+function toFeaturedModel(model: RecommendedModelLike): FeaturedModel {
+	return {
+		id: model.id,
+		name: model.name,
+		description: model.description,
+		labels: model.tags,
+	}
+}
+
+function getModelIdSuffix(id: string): string {
+	const lastSlashIndex = id.lastIndexOf("/")
+	return lastSlashIndex >= 0 ? id.slice(lastSlashIndex + 1) : id
+}
+
+function findFallbackFeaturedModelById(models: FeaturedModel[], id: string): FeaturedModel | undefined {
+	const idSuffix = getModelIdSuffix(id)
+	return models.find((model) => model.id === id || getModelIdSuffix(model.id) === idSuffix)
+}
+
+function mapRecommendedModelToFeaturedModelWithFallback(
+	model: RecommendedModelLike,
+	fallbackModels: FeaturedModel[],
+	defaultLabels: string[] = [],
+): FeaturedModel {
+	const fallbackModel = findFallbackFeaturedModelById(fallbackModels, model.id)
+	const upstreamNameLooksLikeFallback = model.name === model.id || model.name.trim().length === 0
+	const name = upstreamNameLooksLikeFallback ? (fallbackModel?.name ?? model.name) : model.name
+	const description = model.description.trim().length > 0 ? model.description : (fallbackModel?.description ?? "")
+	const labels = model.tags.length > 0 ? model.tags : (fallbackModel?.labels ?? defaultLabels)
+
+	return {
+		id: model.id,
+		name,
+		description,
+		labels,
+	}
+}
+
+export const FEATURED_MODELS: FeaturedModelsByTier = {
+	recommended: CLINE_RECOMMENDED_MODELS_FALLBACK.recommended.map(toFeaturedModel),
+	free: CLINE_RECOMMENDED_MODELS_FALLBACK.free.map(toFeaturedModel),
+}
+
+export function getAllFeaturedModels(modelsByTier: FeaturedModelsByTier = FEATURED_MODELS): FeaturedModel[] {
+	return [...modelsByTier.recommended, ...modelsByTier.free]
+}
+
+export function mapRecommendedModelsToFeaturedModels(data: RecommendedModelsByTier): FeaturedModelsByTier {
+	return {
+		recommended: data.recommended.map((model) =>
+			mapRecommendedModelToFeaturedModelWithFallback(model, FEATURED_MODELS.recommended),
+		),
+		free: data.free.map((model) => mapRecommendedModelToFeaturedModelWithFallback(model, FEATURED_MODELS.free, ["FREE"])),
+	}
+}
+
+export function withFeaturedModelFallback(modelsByTier: FeaturedModelsByTier): FeaturedModelsByTier {
+	const recommended = modelsByTier.recommended.length > 0 ? modelsByTier.recommended : FEATURED_MODELS.recommended
+	const free = modelsByTier.free.length > 0 ? modelsByTier.free : FEATURED_MODELS.free
+	return { recommended, free }
 }

cli/src/exports.ts

@@ -0,0 +1,71 @@
+/**
+ * Cline Library Exports
+ *
+ * This file exports the public API for programmatic use of Cline.
+ * Use these classes and types to embed Cline into your applications.
+ *
+ * @example
+ * ```typescript
+ * import { ClineAgent } from "cline"
+ *
+ * const agent = new ClineAgent()
+ * await agent.initialize({ clientCapabilities: {} })
+ * const session = await agent.newSession({ cwd: process.cwd() })
+ * ```
+ * @module cline
+ */
+
+export { ClineAgent } from "./agent/ClineAgent.js"
+export { ClineSessionEmitter } from "./agent/ClineSessionEmitter.js"
+export type {
+	AcpAgentOptions,
+	AcpSessionState,
+	AcpSessionStatus,
+	Agent,
+	AgentSideConnection,
+	AudioContent,
+	CancelNotification,
+	ClientCapabilities,
+	ClineAcpSession,
+	ClineAgentCapabilities,
+	ClineAgentInfo,
+	ClineAgentOptions,
+	ClinePermissionOption,
+	ClineSessionEvents,
+	ContentBlock,
+	ImageContent,
+	InitializeRequest,
+	InitializeResponse,
+	LoadSessionRequest,
+	LoadSessionResponse,
+	McpServer,
+	ModelInfo,
+	NewSessionRequest,
+	NewSessionResponse,
+	PermissionHandler,
+	PermissionOption,
+	PermissionOptionKind,
+	PromptRequest,
+	PromptResponse,
+	RequestPermissionRequest,
+	RequestPermissionResponse,
+	SessionConfigOption,
+	SessionModelState,
+	SessionNotification,
+	SessionUpdate,
+	SessionUpdatePayload,
+	SessionUpdateType,
+	SetSessionConfigOptionRequest,
+	SetSessionConfigOptionResponse,
+	SetSessionModelRequest,
+	SetSessionModelResponse,
+	SetSessionModeRequest,
+	SetSessionModeResponse,
+	StopReason,
+	TextContent,
+	ToolCall,
+	ToolCallStatus,
+	ToolCallUpdate,
+	ToolKind,
+	TranslatedMessage,
+} from "./agent/public-types.js"

cli/src/hooks/useClineFeaturedModels.ts

@@ -0,0 +1,34 @@
+import { useEffect, useState } from "react"
+import { refreshClineRecommendedModels } from "@/core/controller/models/refreshClineRecommendedModels"
+import {
+	type FeaturedModel,
+	getAllFeaturedModels,
+	mapRecommendedModelsToFeaturedModels,
+	withFeaturedModelFallback,
+} from "../constants/featured-models"
+
+export function useClineFeaturedModels(): FeaturedModel[] {
+	const [featuredModels, setFeaturedModels] = useState<FeaturedModel[]>(() => getAllFeaturedModels())
+
+	useEffect(() => {
+		let cancelled = false
+		void (async () => {
+			try {
+				const recommendedModels = await refreshClineRecommendedModels()
+				const mappedModels = mapRecommendedModelsToFeaturedModels(recommendedModels)
+				const modelsWithFallback = withFeaturedModelFallback(mappedModels)
+				if (!cancelled) {
+					setFeaturedModels(getAllFeaturedModels(modelsWithFallback))
+				}
+			} catch {
+				// Keep local fallback models on error.
+			}
+		})()
+
+		return () => {
+			cancelled = true
+		}
+	}, [])
+
+	return featuredModels
+}

cli/src/index.ts

@@ -8,12 +8,11 @@ import { Command } from "commander"
 import { render } from "ink"
 import React from "react"
 import { ClineEndpoint } from "@/config"
-import { Controller } from "@/core/controller"
+import type { Controller } from "@/core/controller"
 import { StateManager } from "@/core/storage/StateManager"
 import { AuthHandler } from "@/hosts/external/AuthHandler"
 import { HostProvider } from "@/hosts/host-provider"
 import { FileEditProvider } from "@/integrations/editor/FileEditProvider"
-import { openAiCodexOAuthManager } from "@/integrations/openai-codex/oauth"
 import { StandaloneTerminalManager } from "@/integrations/terminal/standalone/StandaloneTerminalManager"
 import { ErrorService } from "@/services/error/ErrorService"
 import { telemetryService } from "@/services/telemetry"
@@ -21,7 +20,7 @@ import { PostHogClientProvider } from "@/services/telemetry/providers/posthog/Po
 import { HistoryItem } from "@/shared/HistoryItem"
 import { Logger } from "@/shared/services/Logger"
 import { Session } from "@/shared/services/Session"
-import { getProviderModelIdKey, ProviderToApiKeyMap } from "@/shared/storage"
+import { getProviderModelIdKey } from "@/shared/storage"
 import { isOpenaiReasoningEffort, OPENAI_REASONING_EFFORT_OPTIONS, type OpenaiReasoningEffort } from "@/shared/storage/types"
 import { version as CLI_VERSION } from "../package.json"
 import { runAcpMode } from "./acp/index.js"
@@ -30,7 +29,8 @@ import { checkRawModeSupport } from "./context/StdinContext"
 import { createCliHostBridgeProvider } from "./controllers"
 import { CliCommentReviewController } from "./controllers/CliCommentReviewController"
 import { CliWebviewProvider } from "./controllers/CliWebviewProvider"
-import { restoreConsole } from "./utils/console"
+import { isAuthConfigured } from "./utils/auth"
+import { restoreConsole, suppressConsoleUnlessVerbose } from "./utils/console"
 import { printInfo, printWarning } from "./utils/display"
 import { selectOutputMode } from "./utils/mode-selection"
 import { parseImagesFromInput, processImagePaths } from "./utils/parser"
@@ -43,6 +43,10 @@ import { autoUpdateOnStartup, checkForUpdates } from "./utils/update"
 import { initializeCliContext } from "./vscode-context"
 import { CLI_LOG_FILE, shutdownEvent, window } from "./vscode-shim"
 
+// CLI-only behavior: suppress console output unless verbose mode is enabled.
+// Kept explicit here so importing the library bundle does not mutate global console methods.
+suppressConsoleUnlessVerbose()
+
 /**
  * Common options shared between runTask and resumeTask
  */
@@ -74,24 +78,7 @@ async function disposeTelemetryServices(): Promise<void> {
 	await Promise.allSettled([telemetryService.dispose(), PostHogClientProvider.getInstance().dispose()])
 }
 
-/**
- * Restore yoloModeToggled to its original value from before this CLI session.
- * This ensures the --yolo flag is session-only and doesn't leak into future runs.
- * Must be called before flushPendingState so the restored value gets persisted.
- */
-function restoreYoloState(): void {
-	if (savedYoloModeToggled !== null) {
-		try {
-			StateManager.get().setGlobalState("yoloModeToggled", savedYoloModeToggled)
-			savedYoloModeToggled = null
-		} catch {
-			// StateManager may not be initialized (e.g., early exit before init)
-		}
-	}
-}
-
 async function disposeCliContext(ctx: CliContext): Promise<void> {
-	restoreYoloState()
 	await ctx.controller.stateManager.flushPendingState()
 	await ctx.controller.dispose()
 	await ErrorService.get().dispose()
@@ -204,12 +191,10 @@ function applyTaskOptions(options: TaskOptions): void {
 		telemetryService.captureHostEvent("max_consecutive_mistakes_flag", String(maxConsecutiveMistakes))
 	}
 
-	// Override yolo mode only if --yolo flag is explicitly passed.
-	// The original value is saved in initializeCli and restored on exit.
+	// Set yolo mode as a session-scoped override so AutoApprove picks it up,
+	// but it is never persisted to disk (setSessionOverride never touches pendingGlobalState).
 	if (options.yolo) {
-		const state = StateManager.get()
-		savedYoloModeToggled = state.getGlobalSettingsKey("yoloModeToggled") ?? false
-		state.setGlobalState("yoloModeToggled", true)
+		StateManager.get().setSessionOverride("yoloModeToggled", true)
 		telemetryService.captureHostEvent("yolo_flag", "true")
 	}
 
@@ -314,9 +299,6 @@ let activeContext: CliContext | null = null
 let isShuttingDown = false
 // Track if we're in plain text mode (no Ink UI) - set by runTask when piped stdin detected
 let isPlainTextMode = false
-// Track the original yoloModeToggled value from before this CLI session so we can restore it on exit.
-// The --yolo flag should only affect the current invocation, not persist across runs.
-let savedYoloModeToggled: boolean | null = null
 
 /**
  * Wait for stdout to fully drain before exiting.
@@ -358,10 +340,6 @@ function setupSignalHandlers() {
 		printWarning(`${signal} received, shutting down...`)
 
 		try {
-			// Restore yolo state before any cleanup - this is idempotent and safe
-			// even if disposeCliContext also calls it (restoreYoloState checks savedYoloModeToggled !== null)
-			restoreYoloState()
-
 			if (activeContext) {
 				const task = activeContext.controller.task
 				if (task) {
@@ -425,7 +403,7 @@ interface InitOptions {
  */
 async function initializeCli(options: InitOptions): Promise<CliContext> {
 	const workspacePath = options.cwd || process.cwd()
-	const { extensionContext, DATA_DIR, EXTENSION_DIR } = initializeCliContext({
+	const { extensionContext, storageContext, DATA_DIR, EXTENSION_DIR } = initializeCliContext({
 		clineDir: options.config,
 		workspaceDir: workspacePath,
 	})
@@ -466,13 +444,9 @@ async function initializeCli(options: InitOptions): Promise<CliContext> {
 		DATA_DIR,
 	)
 
-	await StateManager.initialize(extensionContext as any)
-
+	await StateManager.initialize(storageContext)
 	await ErrorService.initialize()
 
-	// Initialize OpenAI Codex OAuth manager with extension context for secrets storage
-	openAiCodexOAuthManager.initialize(extensionContext)
-
 	const webview = HostProvider.get().createWebviewProvider() as CliWebviewProvider
 	const controller = webview.controller
 
@@ -754,7 +728,7 @@ program
 	.option("-a, --act", "Run in act mode")
 	.option("-p, --plan", "Run in plan mode")
 	.option("-y, --yolo", "Enable yes/yolo mode (auto-approve actions)")
-	.option("-t, --timeout <seconds>", "Timeout in seconds for yes/yolo mode (default: 600)")
+	.option("-t, --timeout <seconds>", "Optional timeout in seconds (applies only when provided)")
 	.option("-m, --model <model>", "Model to use for the task")
 	.option("-v, --verbose", "Show verbose output")
 	.option("-c, --cwd <path>", "Working directory for the task")
@@ -790,9 +764,9 @@ program
 program
 	.command("auth")
 	.description("Authenticate a provider and configure what model is used")
-	.option("-p, --provider <id>", "Provider ID for quick setup (e.g., openai-native, anthropic)")
+	.option("-p, --provider <id>", "Provider ID for quick setup (e.g., openai-native, anthropic, moonshot)")
 	.option("-k, --apikey <key>", "API key for the provider")
-	.option("-m, --modelid <id>", "Model ID to configure (e.g., gpt-4o, claude-sonnet-4-5-20250929)")
+	.option("-m, --modelid <id>", "Model ID to configure (e.g., gpt-4o, claude-sonnet-4-6, kimi-k2.5)")
 	.option("-b, --baseurl <url>", "Base URL (optional, only for openai provider)")
 	.option("-v, --verbose", "Show verbose output")
 	.option("-c, --cwd <path>", "Working directory for the task")
@@ -821,68 +795,6 @@ devCommand
 		await openExternal(CLI_LOG_FILE)
 	})
 
-/**
- * Check if the user has completed onboarding (has any provider configured).
- *
- * Uses `welcomeViewCompleted` as the single source of truth, matching the VS Code extension's approach.
- * If `welcomeViewCompleted` is undefined (first run), checks if ANY provider has credentials
- * and sets the flag accordingly.
- */
-async function isAuthConfigured(): Promise<boolean> {
-	const stateManager = StateManager.get()
-
-	// Check welcomeViewCompleted first - this is the single source of truth
-	const welcomeViewCompleted = stateManager.getGlobalStateKey("welcomeViewCompleted")
-	if (welcomeViewCompleted !== undefined) {
-		return welcomeViewCompleted
-	}
-
-	// welcomeViewCompleted is undefined - run migration logic to check if ANY provider has credentials
-	// This mirrors the extension's migrateWelcomeViewCompleted behavior
-	const hasAnyAuth = await checkAnyProviderConfigured()
-
-	// Set welcomeViewCompleted based on what we found
-	stateManager.setGlobalState("welcomeViewCompleted", hasAnyAuth)
-	await stateManager.flushPendingState()
-
-	return hasAnyAuth
-}
-
-/**
- * Check if ANY provider has valid credentials configured.
- * Used for migration when welcomeViewCompleted is undefined.
- */
-async function checkAnyProviderConfigured(): Promise<boolean> {
-	const stateManager = StateManager.get()
-	const config = stateManager.getApiConfiguration() as Record<string, unknown>
-
-	// Check Cline account (stored as "cline:clineAccountId" in secrets, loaded into config)
-	if (config["clineApiKey"] || config["cline:clineAccountId"]) return true
-
-	// Check OpenAI Codex OAuth (stored in SECRETS_KEYS, loaded into config)
-	if (config["openai-codex-oauth-credentials"]) return true
-
-	// Check all BYO provider API keys (loaded into config from secrets)
-	for (const [provider, keyField] of Object.entries(ProviderToApiKeyMap)) {
-		// Skip cline - already checked above with the correct key
-		if (provider === "cline") continue
-
-		const fields = Array.isArray(keyField) ? keyField : [keyField]
-		for (const field of fields) {
-			if (config[field]) return true
-		}
-	}
-
-	// Check provider-specific settings that indicate configuration
-	// (for providers that don't require API keys like Bedrock with IAM, Ollama, LM Studio)
-	if (config.awsRegion) return true
-	if (config.vertexProjectId) return true
-	if (config.ollamaBaseUrl) return true
-	if (config.lmStudioBaseUrl) return true
-
-	return false
-}
-
 /**
  * Validate that a task exists in history
  * @returns The task history item if found, null otherwise
@@ -983,7 +895,7 @@ program
 	.option("-a, --act", "Run in act mode")
 	.option("-p, --plan", "Run in plan mode")
 	.option("-y, --yolo", "Enable yolo mode (auto-approve actions)")
-	.option("-t, --timeout <seconds>", "Timeout in seconds for yolo mode (default: 600)")
+	.option("-t, --timeout <seconds>", "Optional timeout in seconds (applies only when provided)")
 	.option("-m, --model <model>", "Model to use for the task")
 	.option("-v, --verbose", "Show verbose output")
 	.option("-c, --cwd <path>", "Working directory")

cli/src/lib-import.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest"
+
+describe("library import side effects", () => {
+	it("importing library exports must not mutate console.log", async () => {
+		const originalConsoleLog = console.log
+		await import("./exports")
+		expect(console.log).toBe(originalConsoleLog)
+	}, 30000)
+})

cli/src/utils/auth.ts

@@ -0,0 +1,64 @@
+import { StateManager } from "@/core/storage/StateManager"
+import { ProviderToApiKeyMap } from "@/shared/storage"
+
+/**
+ * Check if the user has completed onboarding (has any provider configured).
+ *
+ * Uses `welcomeViewCompleted` as the single source of truth, matching the VS Code extension's approach.
+ * If `welcomeViewCompleted` is undefined (first run), checks if ANY provider has credentials
+ * and sets the flag accordingly.
+ */
+export async function isAuthConfigured(): Promise<boolean> {
+	const stateManager = StateManager.get()
+
+	// Check welcomeViewCompleted first - this is the single source of truth
+	const welcomeViewCompleted = stateManager.getGlobalStateKey("welcomeViewCompleted")
+	if (welcomeViewCompleted !== undefined) {
+		return welcomeViewCompleted
+	}
+
+	// welcomeViewCompleted is undefined - run migration logic to check if ANY provider has credentials
+	// This mirrors the extension's migrateWelcomeViewCompleted behavior
+	const hasAnyAuth = await checkAnyProviderConfigured()
+
+	// Set welcomeViewCompleted based on what we found
+	stateManager.setGlobalState("welcomeViewCompleted", hasAnyAuth)
+	await stateManager.flushPendingState()
+
+	return hasAnyAuth
+}
+
+/**
+ * Check if ANY provider has valid credentials configured.
+ * Used for migration when welcomeViewCompleted is undefined.
+ */
+export async function checkAnyProviderConfigured(): Promise<boolean> {
+	const stateManager = StateManager.get()
+	const config = stateManager.getApiConfiguration() as Record<string, unknown>
+
+	// Check Cline account (stored as "cline:clineAccountId" in secrets, loaded into config)
+	if (config["clineApiKey"] || config["cline:clineAccountId"]) return true
+
+	// Check OpenAI Codex OAuth (stored in SECRETS_KEYS, loaded into config)
+	if (config["openai-codex-oauth-credentials"]) return true
+
+	// Check all BYO provider API keys (loaded into config from secrets)
+	for (const [provider, keyField] of Object.entries(ProviderToApiKeyMap)) {
+		// Skip cline - already checked above with the correct key
+		if (provider === "cline") continue
+
+		const fields = Array.isArray(keyField) ? keyField : [keyField]
+		for (const field of fields) {
+			if (config[field]) return true
+		}
+	}
+
+	// Check provider-specific settings that indicate configuration
+	// (for providers that don't require API keys like Bedrock with IAM, Ollama, LM Studio)
+	if (config.awsRegion) return true
+	if (config.vertexProjectId) return true
+	if (config.ollamaBaseUrl) return true
+	if (config.lmStudioBaseUrl) return true
+
+	return false
+}

cli/src/utils/console.ts

@@ -12,11 +12,19 @@ export const originalConsoleWarn = console.warn.bind(console)
 export const originalConsoleInfo = console.info.bind(console)
 export const originalConsoleDebug = console.debug.bind(console)
 
-// Check for verbose flag early (before commander parses)
-const isVerbose = process.argv.includes("-v") || process.argv.includes("--verbose")
+/**
+ * Suppress console output unless verbose mode is enabled.
+ *
+ * This is intentionally opt-in and should only be called by the CLI entrypoint.
+ * Library consumers should not have their global console methods mutated as a
+ * side effect of importing the library bundle.
+ */
+export function suppressConsoleUnlessVerbose(argv: string[] = process.argv) {
+	const isVerbose = argv.includes("-v") || argv.includes("--verbose")
+	if (isVerbose) {
+		return
+	}
 
-// Suppress console output unless verbose mode
-if (!isVerbose) {
 	console.log = () => {}
 	console.warn = () => {}
 	console.error = () => {}

cli/src/utils/plain-text-task.ts

@@ -26,7 +26,7 @@ export interface PlainTextTaskOptions {
 	imageDataUrls?: string[]
 	verbose?: boolean
 	jsonOutput?: boolean
-	/** Timeout in seconds (default: 600 = 10 minutes) */
+	/** Timeout in seconds (only applied when explicitly provided) */
 	timeoutSeconds?: number
 	/** Task ID to resume an existing task */
 	taskId?: string
@@ -153,10 +153,14 @@ export async function runPlainTextTask(options: PlainTextTaskOptions): Promise<b
 			throw new Error("Either taskId or prompt must be provided")
 		}
 
-		// Normal mode: wait for task completion
-		const timeoutMs = (options.timeoutSeconds ?? 600) * 1000 // default 10 minutes
-		const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), timeoutMs))
-		await Promise.race([completionPromise, timeoutPromise])
+		// Wait for task completion, with optional timeout only when explicitly configured
+		if (options.timeoutSeconds) {
+			const timeoutMs = options.timeoutSeconds * 1000
+			const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), timeoutMs))
+			await Promise.race([completionPromise, timeoutPromise])
+		} else {
+			await completionPromise
+		}
 	} catch (error) {
 		const errMsg = error instanceof Error ? error.message : String(error)
 		if (jsonOutput) {

cli/src/utils/provider-config.ts

@@ -7,6 +7,8 @@ import type { ApiProvider } from "@shared/api"
 import { getProviderModelIdKey, ProviderToApiKeyMap } from "@shared/storage"
 import { buildApiHandler } from "@/core/api"
 import type { Controller } from "@/core/controller"
+import { refreshOpenRouterModels } from "@/core/controller/models/refreshOpenRouterModels"
+import { refreshVercelAiGatewayModels } from "@/core/controller/models/refreshVercelAiGatewayModels"
 import { StateManager } from "@/core/storage/StateManager"
 import type { BedrockConfig } from "../components/BedrockSetup"
 import { getDefaultModelId } from "../components/ModelPicker"
@@ -40,14 +42,22 @@ export async function applyProviderConfig(options: ApplyProviderConfigOptions):
 		if (actModelKey) config[actModelKey] = finalModelId
 		if (planModelKey) config[planModelKey] = finalModelId
 
-		// For cline/openrouter, also set model info (required for getModel() to return correct model)
+		// Fetch model info from the provider API (not just disk cache) so headless
+		// CLI auth gets correct maxTokens, thinkingConfig, etc.
 		if ((providerId === "cline" || providerId === "openrouter") && controller) {
-			const openRouterModels = await controller.readOpenRouterModels()
+			const openRouterModels = await refreshOpenRouterModels(controller)
 			const modelInfo = openRouterModels?.[finalModelId]
 			if (modelInfo) {
 				stateManager.setGlobalState("actModeOpenRouterModelInfo", modelInfo)
 				stateManager.setGlobalState("planModeOpenRouterModelInfo", modelInfo)
 			}
+		} else if (providerId === "vercel-ai-gateway" && controller) {
+			const vercelModels = await refreshVercelAiGatewayModels(controller)
+			const modelInfo = vercelModels?.[finalModelId]
+			if (modelInfo) {
+				stateManager.setGlobalState("actModeVercelAiGatewayModelInfo", modelInfo)
+				stateManager.setGlobalState("planModeVercelAiGatewayModelInfo", modelInfo)
+			}
 		}
 	}
 
@@ -80,15 +90,18 @@ export async function applyProviderConfig(options: ApplyProviderConfigOptions):
 export interface ApplyBedrockConfigOptions {
 	bedrockConfig: BedrockConfig
 	modelId?: string
+	customModelBaseId?: string // Base model ID for custom ARN/Inference Profile (for capability detection)
 	controller?: Controller
 }
 
 /**
  * Apply Bedrock provider configuration to state
  * Handles AWS-specific fields (authentication, region, credentials)
+ * When customModelBaseId is provided, sets the custom model flags so the system
+ * knows to use the ARN as the model ID and the base model for capability detection.
  */
 export async function applyBedrockConfig(options: ApplyBedrockConfigOptions): Promise<void> {
-	const { bedrockConfig, modelId, controller } = options
+	const { bedrockConfig, modelId, customModelBaseId, controller } = options
 	const stateManager = StateManager.get()
 
 	const config: Record<string, unknown> = {
@@ -108,6 +121,18 @@ export async function applyBedrockConfig(options: ApplyBedrockConfigOptions): Pr
 		if (planModelKey) config[planModelKey] = finalModelId
 	}
 
+	// Handle custom model (Application Inference Profile ARN)
+	if (customModelBaseId) {
+		config.actModeAwsBedrockCustomSelected = true
+		config.planModeAwsBedrockCustomSelected = true
+		config.actModeAwsBedrockCustomModelBaseId = customModelBaseId
+		config.planModeAwsBedrockCustomModelBaseId = customModelBaseId
+	} else {
+		// Ensure custom flags are cleared when using a standard model
+		config.actModeAwsBedrockCustomSelected = false
+		config.planModeAwsBedrockCustomSelected = false
+	}
+
 	// Add optional AWS credentials
 	if (bedrockConfig.awsProfile !== undefined) config.awsProfile = bedrockConfig.awsProfile
 	if (bedrockConfig.awsAccessKey) config.awsAccessKey = bedrockConfig.awsAccessKey

cli/src/vscode-context.ts

@@ -1,23 +1,21 @@
 /**
  * VSCode context stub for CLI mode
- * Provides mock implementations of VSCode extension context
+ * Provides mock implementations of VSCode extension context.
  */
 
-import { mkdirSync } from "node:fs"
 import { fileURLToPath } from "node:url"
 import os from "os"
 import path from "path"
 import { ExtensionRegistryInfo } from "@/registry"
 import { ClineExtensionContext } from "@/shared/cline"
-import { ClineFileStorage } from "@/shared/storage"
+import type { ClineMemento } from "@/shared/storage/ClineStorage"
+import { createStorageContext, type StorageContext } from "@/shared/storage/storage-context"
 import { EnvironmentVariableCollection, ExtensionKind, ExtensionMode, readJson, URI } from "./vscode-shim"
 
 // ES module equivalent of __dirname
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 
-const SETTINGS_SUBFOLDER = "data"
-
 /**
  * CLI-specific state overrides.
  * These values are always returned regardless of what's stored,
@@ -35,33 +33,43 @@ const CLI_STATE_OVERRIDES: Record<string, any> = {
 }
 
 /**
- * File-based Memento store with optional key overrides.
- * Implements VSCode's Memento interface using SyncJsonFileStorage.
+ * Memento adapter that wraps a ClineFileStorage with optional key overrides.
+ * Used for globalState where CLI needs to inject hardcoded overrides.
  */
-class MementoStore extends ClineFileStorage {
-	private overrides: Record<string, any>
+class MementoAdapter implements ClineMemento {
+	constructor(
+		private readonly store: ClineMemento,
+		private readonly overrides: Record<string, any> = {},
+	) {}
 
-	constructor(filePath: string, overrides: Record<string, any> = {}) {
-		super(filePath, "MementoStore")
-		this.overrides = overrides
-	}
-
-	// VSCode Memento interface - override base class get() with overload support
-	override get<T>(key: string): T | undefined
-	override get<T>(key: string, defaultValue: T): T
-	override get<T>(key: string, defaultValue?: T): T | undefined {
+	get<T>(key: string): T | undefined
+	get<T>(key: string, defaultValue: T): T
+	get<T>(key: string, defaultValue?: T): T | undefined {
 		if (key in this.overrides) {
 			return this.overrides[key] as T
 		}
-		const value = super.get<T>(key)
+		const value = this.store.get<T>(key)
 		return value !== undefined ? value : defaultValue
 	}
 
-	override async update(key: string, value: any): Promise<void> {
-		if (key in this.overrides) {
-			return
+	update(key: string, value: any): Thenable<void> {
+		return this.setBatch({ [key]: value })
+	}
+
+	keys(): readonly string[] {
+		return this.store.keys()
+	}
+
+	setBatch(entries: Record<string, any>): Thenable<void> {
+		// Filter out overridden keys and delegate to underlying store
+		const filteredEntries: Record<string, any> = {}
+		for (const [key, value] of Object.entries(entries)) {
+			if (!(key in this.overrides)) {
+				filteredEntries[key] = value
+			}
 		}
-		this.set(key, value)
+		this.store.setBatch(filteredEntries)
+		return Promise.resolve()
 	}
 
 	setKeysForSync(_keys: readonly string[]): void {
@@ -69,81 +77,45 @@ class MementoStore extends ClineFileStorage {
 	}
 }
 
-/**
- * File-based secret storage implementing VSCode's SecretStorage interface.
- * Uses sync storage internally but exposes async API for VSCode compatibility.
- */
-class SecretStore {
-	private storage: ClineFileStorage<string>
-	private onDidChangeEmitter = {
-		event: () => ({ dispose: () => {} }),
-		fire: (_e: any) => {},
-		dispose: () => {},
-	}
-
-	onDidChange = this.onDidChangeEmitter.event
-
-	constructor(filePath: string) {
-		this.storage = new ClineFileStorage<string>(filePath, "SecretStore")
-	}
-
-	get(key: string): Promise<string | undefined> {
-		return Promise.resolve(this.storage.get(key))
-	}
-
-	store(key: string, value: string): Promise<void> {
-		this.storage.set(key, value)
-		return Promise.resolve()
-	}
-
-	delete(key: string): Promise<void> {
-		this.storage.delete(key)
-		return Promise.resolve()
-	}
-}
-
 export interface CliContextConfig {
 	clineDir?: string
-	/** The workspace directory being worked in (for hashing into storage path) */
+	/** The workspace directory being worked in (used to compute workspace storage hash) */
 	workspaceDir?: string
 }
 
-/**
- * Create a short hash of a string for use in directory names
- */
-function hashString(str: string): string {
-	let hash = 0
-	for (let i = 0; i < str.length; i++) {
-		const char = str.charCodeAt(i)
-		hash = (hash << 5) - hash + char
-		hash = hash & hash // Convert to 32bit integer
-	}
-	return Math.abs(hash).toString(16).substring(0, 8)
-}
-
 export interface CliContextResult {
 	extensionContext: ClineExtensionContext
+	storageContext: StorageContext
 	DATA_DIR: string
 	EXTENSION_DIR: string
 	WORKSPACE_STORAGE_DIR: string
 }
 
 /**
- * Initialize the VSCode-like context for CLI mode
+ * Initialize the VSCode-like context for CLI mode.
+ *
+ * Creates a shared StorageContext (the single source of truth for all storage)
+ * and wraps it in a ClineExtensionContext shell for legacy APIs that still
+ * expect the VSCode ExtensionContext shape.
  */
 export function initializeCliContext(config: CliContextConfig = {}): CliContextResult {
 	const CLINE_DIR = config.clineDir || process.env.CLINE_DIR || path.join(os.homedir(), ".cline")
-	const DATA_DIR = path.join(CLINE_DIR, SETTINGS_SUBFOLDER)
 
-	// Workspace storage should always be under ~/.cline/data/workspaces/<hash>/
-	// where hash is derived from the workspace path to keep workspaces isolated
-	const workspacePath = config.workspaceDir || process.cwd()
-	const workspaceHash = hashString(workspacePath)
-	const WORKSPACE_STORAGE_DIR = process.env.WORKSPACE_STORAGE_DIR || path.join(DATA_DIR, "workspaces", workspaceHash)
+	// Create the shared StorageContext — this owns all ClineFileStorage instances.
+	// CLI, JetBrains, and VSCode all share this same file-backed implementation.
+	let storageContext = createStorageContext({
+		clineDir: CLINE_DIR,
+		workspacePath: config.workspaceDir || process.cwd(),
+		workspaceStorageDir: process.env.WORKSPACE_STORAGE_DIR || undefined,
+	})
+	storageContext = {
+		...storageContext,
+		// Storage — delegates to storageContext stores (with CLI overrides for globalState)
+		globalState: new MementoAdapter(storageContext.globalState, CLI_STATE_OVERRIDES),
+	}
 
-	// Ensure directories exist
-	mkdirSync(DATA_DIR, { recursive: true })
-	mkdirSync(WORKSPACE_STORAGE_DIR, { recursive: true })
+	const DATA_DIR = storageContext.dataDir
+	const WORKSPACE_STORAGE_DIR = storageContext.workspaceStoragePath
 
 	// For CLI, extension dir is the package root (one level up from dist/)
 	const EXTENSION_DIR = path.resolve(__dirname, "..")
@@ -160,38 +132,30 @@ export function initializeCliContext(config: CliContextConfig = {}): CliContextR
 		extensionKind: ExtensionKind.UI,
 	}
 
+	// Build the ClineExtensionContext shell. All storage delegates to storageContext —
+	// there are NO separate ClineFileStorage instances here.
 	const extensionContext: ClineExtensionContext = {
 		extension: extension,
 		extensionMode: EXTENSION_MODE,
 
-		// Set up KV stores (globalState has CLI-specific overrides)
-		globalState: new MementoStore(path.join(DATA_DIR, "globalState.json"), CLI_STATE_OVERRIDES),
-		secrets: new SecretStore(path.join(DATA_DIR, "secrets.json")),
-
-		// Set up URIs
+		// URIs / paths
 		storageUri: URI.file(WORKSPACE_STORAGE_DIR),
 		storagePath: WORKSPACE_STORAGE_DIR,
 		globalStorageUri: URI.file(DATA_DIR),
 		globalStoragePath: DATA_DIR,
-
-		// Logs
 		logUri: URI.file(DATA_DIR),
 		logPath: DATA_DIR,
-
 		extensionUri: URI.file(EXTENSION_DIR),
 		extensionPath: EXTENSION_DIR,
 		asAbsolutePath: (relPath: string) => path.join(EXTENSION_DIR, relPath),
 
 		subscriptions: [],
-
 		environmentVariableCollection: new EnvironmentVariableCollection() as any,
-
-		// Workspace state
-		workspaceState: new MementoStore(path.join(WORKSPACE_STORAGE_DIR, "workspaceState.json")),
 	}
 
 	return {
 		extensionContext,
+		storageContext,
 		DATA_DIR,
 		EXTENSION_DIR,
 		WORKSPACE_STORAGE_DIR,

cli/tsconfig.lib.json

@@ -0,0 +1,20 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"declaration": true,
+		"emitDeclarationOnly": true,
+		"declarationMap": false,
+		"noCheck": true,
+		"noResolve": true,
+		"outDir": "dist/types"
+	},
+	"include": [
+		"src/exports.ts",
+		"src/agent/public-types.ts",
+		"src/agent/ClineAgent.ts",
+		"src/agent/ClineSessionEmitter.ts",
+		"src/agent/types.ts",
+		"src/agent/messageTranslator.ts",
+		"src/agent/permissionHandler.ts"
+	]
+}

cli/vitest.config.ts

@@ -5,11 +5,28 @@ export default defineConfig({
 	test: {
 		globals: true,
 		environment: "node",
-		include: ["src/**/*.test.{ts,tsx}", "tests/**/*.test.{ts,tsx}"],
 		coverage: {
 			reporter: ["text", "json", "html"],
 			exclude: ["node_modules/", "dist/"],
 		},
+		projects: [
+			{
+				extends: true,
+				test: {
+					name: "unit",
+					include: ["src/**/*.test.{ts,tsx}", "tests/**/*.test.{ts,tsx}"],
+					exclude: ["src/**/*.markdown.test.tsx"],
+				},
+			},
+			{
+				extends: true,
+				test: {
+					name: "markdown",
+					include: ["src/**/*.markdown.test.tsx"],
+					env: { FORCE_COLOR: "3" },
+				},
+			},
+		],
 	},
 	resolve: {
 		alias: {

docs/cline-cli/acp-editor-integrations.mdx

@@ -202,15 +202,15 @@ If Cline can't access files or run commands:
     Learn about Cline CLI's core capabilities and use cases.
   </Card>
   
-  <Card title="Three Core Flows" icon="route" href="/cline-cli/three-core-flows">
-    Master interactive mode, headless automation, and multi-instance workflows.
+  <Card title="Headless Mode" icon="robot" href="/cline-cli/three-core-flows">
+    Run Cline autonomously in scripts, CI/CD pipelines, and automated workflows.
   </Card>
   
-  <Card title="Skills" icon="graduation-cap" href="/features/skills">
+  <Card title="Skills" icon="graduation-cap" href="/customization/skills">
     Understand how Cline's Skills work across all editors via ACP.
   </Card>
   
-  <Card title="Hooks" icon="link" href="/features/hooks/index">
+  <Card title="Hooks" icon="link" href="/customization/hooks">
     Learn how to enforce policies with Hooks in any editor.
   </Card>
 </Columns>

docs/cline-cli/cli-reference-deprecated.mdx

@@ -1,482 +0,0 @@
----
-title: "CLI Reference (Deprecated)"
-description: "Command reference for Cline CLI versions earlier than 2.0.0 (deprecated). For the latest commands and options, see the current Cline CLI reference."
----
-
-Complete command reference for Cline CLI. Use this for detailed documentation on all commands, options, and configuration.
-
-For quick help in your terminal:
-
-```bash
-cline --help          # Show all commands
-cline task --help     # Show task-specific commands
-man cline            # View the full manual page
-```
-
-## Manual Page
-
-The complete manual page for the Cline CLI:
-
-```
-CLINE(1)                         User Commands                        CLINE(1)
-
-NAME
-       cline - orchestrate and interact with Cline AI coding agents
-
-SYNOPSIS
-       cline [prompt] [options]
-
-       cline command [subcommand] [options] [arguments]
-
-DESCRIPTION
-       Try: cat README.md | cline "Summarize this for me:"
-
-       cline is a command-line interface for orchestrating multiple Cline AI
-       coding agents.  Cline is an autonomous AI agent who can read, write,
-       and execute code across your projects.  He operates through a
-       client-server architecture where Cline Core runs as a standalone
-       service, and the CLI acts as a scriptable interface for managing tasks,
-       instances, and agent interactions.
-
-       The CLI is designed for both interactive use and automation, making it
-       ideal for CI/CD pipelines, parallel task execution, and terminal-based
-       workflows.  Multiple frontends (CLI, VSCode, JetBrains) can attach to
-       the same Cline Core instance, enabling seamless task handoff between
-       environments.
-
-MODES OF OPERATION
-       Instant Task Mode
-              The simplest invocation: cline "prompt here" immediately spawns
-              an instance, creates a task, and enters chat mode.  This is
-              equivalent to running cline instance new && cline task new &&
-              cline task chat in sequence.
-
-       Subcommand Mode
-              Advanced usage with explicit control: cline <command>
-              [subcommand] [options] provides fine-grained control over
-              instances, tasks, authentication, and configuration.
-
-AGENT BEHAVIOR
-       Cline operates in two primary modes:
-
-       ACT MODE
-              Cline actively uses tools to accomplish tasks.  He can read
-              files, write code, execute commands, use a headless browser, and
-              more.  This is the default mode for task execution.
-
-       PLAN MODE
-              Cline gathers information and creates a detailed plan before
-              implementation.  He explores the codebase, asks clarifying
-              questions, and presents a strategy for user approval before
-              switching to ACT MODE.
-
-INSTANT TASK OPTIONS
-       When using the instant task syntax cline "prompt" the following options
-       are available:
-
-       -o, --oneshot
-              Full autonomous mode.  Cline completes the task and stops
-              following after completion.  Example: cline -o "what's 6 + 8?"
-
-       -s, --setting setting value
-              Override a setting for this task
-
-       -y, --no-interactive, --yolo
-              Enable fully autonomous mode.  Disables all interactivity:
-
-              • ask_followup_question tool is disabled
-
-              • attempt_completion happens automatically
-
-              • execute_command runs in non-blocking mode with timeout
-
-              • PLAN MODE automatically switches to ACT MODE
-
-       -m, --mode mode
-              Starting mode.  Options: act (default), plan
-
-       -w, --workspace path
-              Additional workspace paths.  Can be specified multiple times to
-              include multiple directories.  The current working directory is
-              always included as the first workspace.  Example: cline -w
-              /path/to/other/project "refactor shared code"
-
-GLOBAL OPTIONS
-       These options apply to all subcommands:
-
-       -F, --output-format format
-              Output format.  Options: rich (default), json, plain
-
-       -h, --help
-              Display help information for the command.
-
-       -v, --verbose
-              Enable verbose output for debugging.
-
-COMMANDS
-   Authentication
-       cline auth [provider] [key]
-
-       cline a [provider] [key]
-              Configure authentication for AI model providers.  Launches an
-              interactive wizard if no arguments provided.  If provider is
-              specified without a key, prompts for the key or launches the
-              appropriate OAuth flow.
-
-   Instance Management
-       Cline Core instances are independent agent processes that can run in
-       the background.  Multiple instances can run simultaneously, enabling
-       parallel task execution.
-
-       cline instance
-
-       cline i
-              Display instance management help.
-
-       cline instance new [-d|--default]
-
-       cline i n [-d|--default]
-              Spawn a new Cline Core instance.  Use --default to set it as
-              the default instance for subsequent commands.
-
-       cline instance list
-
-       cline i l
-              List all running Cline Core instances with their addresses and
-              status.
-
-       cline instance default address
-
-       cline i d address
-              Set the default instance to avoid specifying --address in task
-              commands.
-
-       cline instance kill address [-a|--all]
-
-       cline i k address [-a|--all]
-              Terminate a Cline Core instance.  Use --all to kill all running
-              instances.
-
-   Task Management
-       Tasks represent individual work items that Cline executes.  Tasks
-       maintain conversation history, checkpoints, and settings.
-
-       cline task [-a|--address ADDR]
-
-       cline t [-a|--address ADDR]
-              Display task management help.  The --address flag specifies
-              which Cline Core instance to use (e.g., localhost:50052).
-
-       cline task new prompt [options]
-
-       cline t n prompt [options]
-              Create a new task in the default or specified instance.
-              Options:
-
-              -s, --setting setting value
-                     Set task-specific settings
-
-              -y, --no-interactive, --yolo
-                     Enable autonomous mode
-
-              -m, --mode mode
-                     Starting mode (act or plan)
-
-       cline task open task-id [options]
-
-       cline t o task-id [options]
-              Resume a previous task from history.  Accepts the same options
-              as task new.
-
-       cline task list
-
-       cline t l
-              List all tasks in history with their id and snippet
-
-       cline task chat
-
-       cline t c
-              Enter interactive chat mode for the current task.  Allows
-              back-and-forth conversation with Cline.
-
-       cline task send [message] [options]
-
-       cline t s [message] [options]
-              Send a message to Cline.  If no message is provided, reads from
-              stdin.  Options:
-
-              -a, --approve
-                     Approve Cline's proposed action
-
-              -d, --deny
-                     Deny Cline's proposed action
-
-              -f, --file FILE
-                     Attach a file to the message
-
-              -y, --no-interactive, --yolo
-                     Enable autonomous mode
-
-              -m, --mode mode
-                     Switch mode (act or plan)
-
-       cline task view [-f|--follow] [-c|--follow-complete]
-
-       cline t v [-f|--follow] [-c|--follow-complete]
-              Display the current conversation.  Use --follow to stream
-              updates in real-time, or --follow-complete to follow until task
-              completion.
-
-       cline task restore checkpoint
-
-       cline t r checkpoint
-              Restore the task to a previous checkpoint state.
-
-       cline task pause
-
-       cline t p
-              Pause task execution.
-
-   Configuration
-       Configuration can be set globally.  Override these global settings for
-       a task using the --setting flag
-
-       cline config
-
-       cline c
-
-       cline config set key value
-
-       cline c s key value
-              Set a configuration variable.
-
-       cline config get key
-
-       cline c g key
-              Read a configuration variable.
-
-       cline config list
-
-       cline c l
-              List all configuration variables and their values.
-
-   Context Window Configuration
-       For local model providers, you can configure the context window size:
-
-       Ollama
-              cline config s ollama-api-options-ctx-num=32768
-
-       LM Studio
-              cline config s lm-studio-max-tokens=32768
-
-       For other providers (Anthropic, OpenRouter, etc.), the context window
-       is defined per model in the model metadata and is not user-settable.
-       Cline uses each model's built-in context limits automatically.
-
-TASK SETTINGS
-       Task settings are persisted in the ~/.cline/x/tasks directory.  When
-       resuming a task with cline task open, task settings are automatically
-       restored.
-
-       Common settings include:
-
-       yolo   Enable autonomous mode (true/false)
-
-       mode   Starting mode (act/plan)
-
-       hooks_enabled
-              Enable or disable hooks for the task (true/false)
-
-HOOKS INTEGRATION
-       Hooks let you inject custom logic into Cline's workflow at key moments.
-       They can validate operations before they execute, monitor tool usage,
-       and shape AI decisions. This allows you to integrate hooks into
-       automated workflows, CI/CD pipelines, and headless task execution.
-
-       Enable hooks for a task:
-
-              cline "prompt" -s hooks_enabled=true
-
-       Configure hooks globally:
-
-              cline config set hooks-enabled=true
-              cline config get hooks-enabled
-
-       Note: Hooks in the CLI are only supported on macOS and Linux.
-
-       For complete hooks documentation, see:
-       <https://docs.cline.bot/features/hooks/index>
-
-NOTES & EXAMPLES
-       The cline task send and cline task new commands support reading from
-       stdin, enabling powerful pipeline compositions:
-
-              cat requirements.txt | cline task send
-              echo "Refactor this code" | cline -y
-
-   Instance Management
-       Manage multiple Cline instances:
-
-              # Start a new instance and make it default
-              cline instance new --default
-
-              # List all running instances
-              cline instance list
-
-              # Kill a specific instance
-              cline instance kill localhost:50052
-
-              # Kill all CLI instances
-              cline instance kill --all-cli
-
-   Task History
-       Work with task history:
-
-              # List previous tasks
-              cline task list
-
-              # Resume a previous task
-              cline task open 1760501486669
-
-              # View conversation history
-              cline task view
-
-              # Start interactive chat with this task
-              cline task chat
-
-ARCHITECTURE
-       Cline operates on a three-layer architecture:
-
-       Presentation Layer
-              User interfaces (CLI, VSCode, JetBrains) that connect to Cline
-              Core via gRPC
-
-       Cline Core
-              The autonomous agent service handling task management, AI model
-              integration, state management, tool orchestration, and real-time
-              streaming updates
-
-       Host Provider Layer
-              Environment-specific integrations (VSCode APIs, JetBrains APIs,
-              shell APIs) that Cline Core uses to interact with the host
-              system
-
-BUGS
-       Report bugs at: <https://github.com/cline/cline/issues>
-
-       For real-time help, join the Discord community at:
-       <https://discord.gg/cline>
-
-SEE ALSO
-       Full documentation: <https://docs.cline.bot>
-
-AUTHORS
-       Cline is developed by the Cline Bot Inc. and the open source community.
-
-COPYRIGHT
-       Copyright © 2025 Cline Bot Inc. Licensed under the Apache License 2.0.
-```
-
-## JSON output (-F json)
-
-When you run a command with `-F json` (or `--output-format json`), Cline prints each client message as JSON.
-
-### ClineMessage schema
-
-| Field | Type | Required | Notes |
-|-------|------|----------|-------|
-| `type` | `"ask" or "say"` | Yes | Top-level message category. |
-| `text` | `string` | Yes | Human-readable message content. |
-| `ts` | `number` | Yes | Unix epoch timestamp in milliseconds. |
-| `reasoning` | `string` | No | Omitted when empty. |
-| `say` | `string` | No | Omitted when empty. Present when `type` is `"say"`. |
-| `ask` | `string` | No | Omitted when empty. Present when `type` is `"ask"`. |
-| `partial` | `boolean` | No | Omitted when false. `true` for streaming updates. |
-| `images` | `string[]` | No | Omitted when empty. Image URIs when included with a message. |
-| `files` | `string[]` | No | Omitted when empty. File paths when attached to a message. |
-| `lastCheckpointHash` | `string` | No | Omitted when empty. Git checkpoint hash when available. |
-| `isCheckpointCheckedOut` | `boolean` | No | Omitted when false. `true` if Cline checked out a checkpoint. |
-| `isOperationOutsideWorkspace` | `boolean` | No | Omitted when false. `true` if an operation happened outside the workspace. |
-
-<Note>
-Most fields are optional and omitted when empty. If you parse this output, treat missing fields as “not present”, not as empty strings.
-</Note>
-
-### Example
-
-```json
-{
-  "type": "say",
-  "text": "Cline is about to run a command.",
-  "ts": 1760501486669,
-  "say": "command",
-  "partial": false
-}
-```
-
-### Shell Completion
-
-Generate autocompletion scripts for various shells:
-
-#### Bash
-
-```bash
-# Generate bash completion
-cline completion bash > /etc/bash_completion.d/cline
-
-# Or for user-level installation
-cline completion bash > ~/.local/share/bash-completion/completions/cline
-```
-
-#### Zsh
-
-```bash
-# Generate zsh completion
-cline completion zsh > "${fpath[1]}/_cline"
-
-# Or add to your .zshrc
-echo 'source <(cline completion zsh)' >> ~/.zshrc
-```
-
-#### Fish
-
-```bash
-# Generate fish completion
-cline completion fish > ~/.config/fish/completions/cline.fish
-```
-
-#### PowerShell
-
-```powershell
-# Generate PowerShell completion
-cline completion powershell > cline.ps1
-
-# Add to your PowerShell profile
-Add-Content $PROFILE "cline completion powershell | Out-String | Invoke-Expression"
-```
-
-### Version Command
-
-```bash
-# Show version information
-cline version
-```
-
-### Environment Variables
-
-#### CLINE_DIR
-
-Override the default Cline directory location:
-
-```bash
-# Override default Cline directory
-export CLINE_DIR=/custom/path
-
-# Default: ~/.cline
-```
-
-This directory is used for:
-- Instance registry database
-- Configuration files
-- Task history
-- Checkpoints

docs/cline-cli/cli-reference.mdx

@@ -3,8 +3,6 @@ title: "CLI Reference"
 description: "Complete command reference for Cline CLI including all commands, flags, and configuration options"
 ---
 
-# CLI Reference
-
 This page documents all available commands, flags, and configuration options for Cline CLI. For quick help in your terminal, use:
 
 ```bash
@@ -316,7 +314,7 @@ When using `--json`, each message is output as a JSON object (one per line):
 
 Cline stores all data in `~/.cline/` by default:
 
-```
+```text
 ~/.cline/
 ├── data/                    # Configuration directory
 │   ├── globalState.json     # Global settings
@@ -416,8 +414,8 @@ cline auth -p openai -k your-key -b https://api.example.com/v1
     Keyboard shortcuts, slash commands, and file mentions.
   </Card>
   
-  <Card title="CLI Workflows" icon="route" href="/cline-cli/three-core-flows">
-    Interactive mode, direct execution, and automation patterns.
+  <Card title="Headless Mode" icon="robot" href="/cline-cli/three-core-flows">
+    Run Cline autonomously in scripts, CI/CD pipelines, and automated workflows.
   </Card>
   
   <Card title="Configuration" icon="gear" href="/cline-cli/configuration">

docs/cline-cli/configuration.mdx

@@ -38,7 +38,7 @@ Rules help Cline understand your project's conventions, coding standards, and pr
 
 ### Workflows Tab
 
-View and manage [workflows](/features/slash-commands/workflows/index):
+View and manage [workflows](/customization/workflows):
 
 - List available workflows
 - View workflow definitions
@@ -46,7 +46,7 @@ View and manage [workflows](/features/slash-commands/workflows/index):
 
 ### Hooks Tab
 
-Configure [hooks](/features/hooks/index) for custom logic integration:
+Configure [hooks](/customization/hooks) for custom logic integration:
 
 - Enable/disable hooks globally
 - View configured hook scripts
@@ -58,7 +58,7 @@ Hooks must be enabled via settings. Use `cline config` to toggle `hooks-enabled`
 
 ### Skills Tab
 
-Manage [skills](/features/skills) that extend Cline's capabilities:
+Manage [skills](/customization/skills) that extend Cline's capabilities:
 
 - View available skills
 - Enable/disable specific skills
@@ -68,11 +68,13 @@ Manage [skills](/features/skills) that extend Cline's capabilities:
 
 Cline stores configuration in `~/.cline/data/`:
 
-```
+```text
 ~/.cline/
 ├── data/                    # Configuration directory
 │   ├── globalState.json     # Global settings
 │   ├── secrets.json         # API keys (encrypted)
+│   ├── settings/            # Settings files
+│   │   └── cline_mcp_settings.json  # MCP server configuration
 │   ├── workspace/           # Workspace-specific state
 │   └── tasks/               # Task history and data
 └── log/                     # Log files
@@ -172,6 +174,46 @@ cline --config ~/.cline-work "review this PR"
 cline --config ~/.cline-personal "help me with this side project"
 ```
 
+## MCP Server Configuration
+
+Cline CLI supports [MCP (Model Context Protocol)](/mcp/mcp-overview) servers, giving you access to external tools and data sources directly from the terminal. The CLI uses the same MCP configuration format as the VS Code extension.
+
+### Setting Up MCP Servers
+
+To configure MCP servers for the CLI, create or edit the settings file at:
+
+```
+~/.cline/data/settings/cline_mcp_settings.json
+```
+
+The file uses the same JSON format as the VS Code extension:
+
+```json
+{
+  "mcpServers": {
+    "my-server": {
+      "command": "node",
+      "args": ["/path/to/server.js"],
+      "env": {
+        "API_KEY": "your_api_key"
+      },
+      "alwaysAllow": ["tool1", "tool2"],
+      "disabled": false
+    }
+  }
+}
+```
+
+For the full configuration reference including STDIO and SSE transport types, see [Adding and Configuring MCP Servers](/mcp/adding-and-configuring-servers).
+
+<Note>
+The CLI does not yet have a `/mcp` slash command for managing MCP servers interactively. For now, you'll need to edit the `cline_mcp_settings.json` file directly.
+</Note>
+
+### Custom Config Directory
+
+If you use the `CLINE_DIR` environment variable or `--config` flag, the MCP settings file will be located at `<your-config-dir>/data/settings/cline_mcp_settings.json` instead.
+
 ## Configuration for Local Providers
 
 ### Ollama
@@ -268,8 +310,8 @@ cline auth  # Re-authenticate
 ## Next Steps
 
 <Columns cols={2}>
-  <Card title="CLI Workflows" icon="route" href="/cline-cli/three-core-flows">
-    Learn about interactive mode, direct execution, and automation patterns.
+  <Card title="Headless Mode" icon="robot" href="/cline-cli/three-core-flows">
+    Run Cline autonomously in scripts, CI/CD pipelines, and automated workflows.
   </Card>
   
   <Card title="CLI Reference" icon="terminal" href="/cline-cli/cli-reference">

docs/cline-cli/getting-started.mdx

@@ -0,0 +1,457 @@
+---
+title: "Getting Started"
+description: "Run Cline AI coding agents directly in your terminal with an interactive CLI or automated workflows"
+---
+
+## What is Cline CLI?
+
+Cline CLI brings the full power of Cline to your terminal. Whether you prefer an interactive experience or automated workflows for CI/CD pipelines, the CLI adapts to your needs.
+
+The CLI supports macOS, Linux, and Windows, and works with all the same AI providers as the VS Code extension.
+
+## Two Ways to Use Cline CLI
+
+The CLI operates in two distinct modes, automatically selecting the appropriate one based on how you invoke it:
+
+### Interactive Mode
+
+Interactive mode is designed for **hands-on development sessions** where you want to collaborate with Cline in real-time. It provides a rich terminal interface that feels like chatting with an AI assistant.
+
+**When it activates:** Running `cline` without arguments, or when stdin is a TTY (terminal).
+
+```bash
+cline
+```
+
+Key features:
+
+- **Real-time conversation** - Type messages, see Cline's responses, and iterate on tasks
+- **Visual feedback** - Animated welcome screen, syntax-highlighted code, and progress indicators
+- **File mentions** with `@` - Reference workspace files with fuzzy search autocomplete
+- **Slash commands** with `/` - Quick access to `/settings`, `/history`, `/models`, and workflows
+- **Keyboard shortcuts** - `Tab` to toggle Plan/Act, `Shift+Tab` for auto-approve all
+- **Session summaries** - See tasks completed, files modified, and token usage on exit
+- **Settings panel** - Configure providers, models, and features without leaving the CLI
+
+Interactive mode keeps you in control. You review Cline's plan, approve or modify actions, and guide the conversation.
+
+[Learn more about interactive mode →](/cline-cli/interactive-mode)
+
+### Headless Mode (Non-Interactive)
+
+Headless mode is designed for **automation, scripting, and CI/CD pipelines** where human interaction isn't possible or desired.
+
+**When it activates:** Using the `-y`/`--yolo` flag, `--json` flag, piping input/output, or when stdin is not a TTY.
+
+```bash
+# Headless with auto-approval (YOLO mode)
+cline -y "Run tests and fix any failures"
+
+# Headless with JSON output for parsing
+cline --json "List all TODO comments" | jq '.text'
+
+# Headless via piped input
+cat README.md | cline "Summarize this document"
+
+# Chain multiple headless commands
+git diff | cline -y "explain these changes" | cline -y "write a commit message"
+```
+
+Key features:
+
+- **No visual interface** - Clean text or JSON output suitable for scripting
+- **Automatic execution** - With `-y`, Cline approves all actions and runs autonomously
+- **Process control** - Exits automatically when the task completes
+- **Piped workflows** - Read from stdin, write to stdout, chain with other commands
+- **Machine-readable output** - Use `--json` to get structured output for parsing
+
+<Warning>
+Headless mode with `-y` gives Cline full autonomy. Run on a clean git branch so you can easily revert changes if needed.
+</Warning>
+
+### Mode Detection Summary
+
+Cline automatically detects which mode to use based on your invocation. This table shows how different command patterns trigger each mode, helping you predict behavior in scripts and interactive sessions.
+
+| Invocation | Mode | Reason |
+|------------|------|--------|
+| `cline` | Interactive | No arguments, TTY connected |
+| `cline "task"` | Interactive | TTY connected |
+| `cline -y "task"` | Headless | YOLO flag forces headless |
+| `cline --json "task"` | Headless | JSON flag forces headless |
+| `cat file \| cline "task"` | Headless | stdin is piped |
+| `cline "task" > output.txt` | Headless | stdout is redirected |
+
+[Learn more about headless mode →](/cline-cli/three-core-flows)
+
+## Supported Model Providers
+
+Cline CLI supports all providers available in the VS Code extension:
+
+- **Anthropic** (Claude)
+- **OpenAI** (GPT-4o, GPT-4)
+- **OpenAI Codex** (ChatGPT subscription)
+- **OpenRouter**
+- **AWS Bedrock**
+- **Google Gemini**
+- **X AI (Grok)**
+- **Cerebras**
+- **DeepSeek**
+- **Ollama** (local models)
+- **LM Studio** (local models)
+- **OpenAI Compatible** (any compatible API)
+
+During setup, authenticate with `cline auth` to configure your preferred provider. [See authentication →](#authenticate)
+
+## What You Can Build
+
+### Automated Code Maintenance
+
+Keep your codebase healthy with automated fixes. Cline scans for issues and applies corrections across multiple files.
+
+```bash
+cline -y "Fix all ESLint errors in src/"
+```
+Finds and fixes linting violations throughout your source directory.
+
+```bash
+cline -y "Update all deprecated React lifecycle methods"
+```
+Migrates legacy code patterns to modern equivalents (e.g., `componentWillMount` → `useEffect`).
+
+```bash
+cline -y "Update dependencies with known vulnerabilities"
+```
+Identifies outdated packages with security issues and updates them to safe versions.
+
+### CI/CD Integration
+
+Integrate Cline into your continuous integration pipelines for automated code review and documentation.
+
+```bash
+git diff origin/main | cline -y "Review these changes for issues"
+```
+Pipes your PR diff to Cline for automated code review, catching bugs and style issues before merge.
+
+```bash
+git log --oneline v1.0..v1.1 | cline -y "Write release notes"
+```
+Generates human-readable release notes from your commit history between two tags.
+
+```bash
+cline -y "Run tests and fix failures" --timeout 600
+```
+Executes your test suite, analyzes failures, and attempts fixes with a 10-minute timeout.
+
+### Development Workflows
+
+From quick edits to complex refactors, Cline adapts to your workflow.
+
+```bash
+cline
+```
+Launches interactive mode for exploratory development and back-and-forth collaboration.
+
+```bash
+cline "Refactor this function to use async/await"
+```
+Executes a focused task directly from the command line with approval prompts at key steps.
+
+```bash
+cline "Based on @src/api.ts, add error handling to all endpoints"
+```
+Uses file mentions (`@`) to give Cline context about specific files in your workspace.
+
+### Custom Shell Pipelines
+
+Chain Cline with other CLI tools to build powerful automation workflows.
+
+```bash
+gh pr diff 123 | cline -y "Review this PR"
+```
+Fetches a GitHub PR diff and pipes it directly to Cline for review.
+
+```bash
+cline --json "List all TODO comments" | jq '.text'
+```
+Outputs structured JSON that you can process with tools like `jq` for scripting.
+
+```bash
+git diff | cline -y "explain" | cline -y "write a haiku about these changes"
+```
+Chains multiple Cline invocations together for creative multi-step workflows.
+
+## Features at a Glance
+
+| Feature | Interactive Mode | Non-Interactive Mode |
+|---------|------------------|----------------------|
+| Interactive chat | ✓ | - |
+| File mentions (@) | ✓ | ✓ (inline) |
+| Slash commands (/) | ✓ | - |
+| Settings panel | ✓ | `cline config` |
+| Plan/Act toggle | ✓ (Tab) | `-p` / `-a` flags |
+| Auto-approve | ✓ (Shift+Tab) | `-y` flag |
+| Session summary | ✓ | - |
+| JSON output | - | `--json` |
+| Piped input | - | ✓ |
+
+---
+
+## Installation & Setup
+
+In just a few minutes, you can install the CLI, authenticate with your preferred AI provider, and start running tasks from any directory on your machine.
+
+### Prerequisites
+
+Cline CLI requires **Node.js version 20 or higher**. We recommend Node.js 22 for the best experience.
+
+Check your Node.js version:
+
+```bash
+node --version
+```
+
+If you need to install or update Node.js, visit [nodejs.org](https://nodejs.org) or use a version manager like [nvm](https://github.com/nvm-sh/nvm).
+
+### Install Cline CLI
+
+Install globally via npm:
+
+```bash
+npm install -g cline
+```
+
+Verify the installation:
+
+```bash
+cline version
+```
+
+<Tip>
+To install a specific version, use `npm install -g cline@2.0.0`. Check [npm](https://www.npmjs.com/package/cline) for available versions.
+</Tip>
+
+### Authenticate
+
+After installation, run the authentication wizard:
+
+```bash
+cline auth
+```
+
+This launches an interactive wizard with multiple options. Choose the method that works best for your workflow.
+
+#### Option 1: Sign in with Cline (Recommended)
+
+Select **"Sign in with Cline"** to authenticate with your Cline account via OAuth. Your browser opens automatically to complete sign-in.
+
+#### Option 2: Sign in with ChatGPT Subscription
+
+If you have a ChatGPT Plus or Pro subscription, select **"Sign in with ChatGPT Subscription"**. This uses OpenAI's Codex OAuth to authenticate with your existing subscription.
+
+#### Option 3: Import from Existing Tools
+
+Already using another AI coding CLI? Cline can import your existing configuration:
+
+- **Import from Codex CLI** - Imports credentials from `~/.codex/auth.json`
+- **Import from OpenCode** - Imports configuration from `~/.local/share/opencode/auth.json`
+
+#### Option 4: Bring Your Own API Key
+
+Select **"Bring your own API key"** to manually configure any supported provider. Or skip the wizard entirely with flags:
+
+```bash
+# Anthropic (Claude)
+cline auth -p anthropic -k sk-ant-api-xxxxx -m claude-sonnet-4-5-20250929
+
+# OpenAI
+cline auth -p openai-native -k sk-xxxxx -m gpt-4o
+
+# OpenRouter
+cline auth -p openrouter -k sk-or-xxxxx -m anthropic/claude-sonnet-4-5-20250929
+
+# OpenAI-compatible provider with custom base URL
+cline auth -p openai -k your-api-key -b https://api.example.com/v1
+```
+
+**Quick Setup Flags:**
+
+| Flag | Description |
+|------|-------------|
+| `-p, --provider <id>` | Provider ID (e.g., `anthropic`, `openai-native`, `openrouter`) |
+| `-k, --apikey <key>` | Your API key |
+| `-m, --modelid <id>` | Model ID (e.g., `claude-sonnet-4-5-20250929`, `gpt-4o`) |
+| `-b, --baseurl <url>` | Base URL for OpenAI-compatible providers |
+
+<Tip>
+Flags are especially useful for scripting, CI/CD environments, or setting up multiple machines.
+</Tip>
+
+#### Supported Providers
+
+| Provider | Provider ID | Notes |
+|----------|-------------|-------|
+| Anthropic | `anthropic` | Direct Claude API access |
+| OpenAI | `openai-native` | GPT-4o, GPT-4, etc. |
+| OpenAI Codex | `openai-codex` | ChatGPT subscription OAuth |
+| OpenRouter | `openrouter` | Access multiple providers |
+| AWS Bedrock | `bedrock` | Claude via AWS |
+| Google Gemini | `gemini` | Gemini Pro, etc. |
+| X AI (Grok) | `xai` | Grok models |
+| Cerebras | `cerebras` | Fast inference |
+| DeepSeek | `deepseek` | DeepSeek models |
+| Ollama | `ollama` | Local models |
+| LM Studio | `lmstudio` | Local models |
+| OpenAI Compatible | `openai` | Any OpenAI-compatible API |
+
+### Verify Your Setup
+
+Confirm everything is working with a simple test:
+
+```bash
+cline "What is 2 + 2?"
+```
+
+If Cline responds with an answer, your installation and authentication are complete.
+
+Check your current configuration:
+
+```bash
+cline config
+```
+
+### Quick Start
+
+Now you're ready to use Cline. Choose how you want to work:
+
+#### Interactive Mode
+
+Launch the interactive CLI for development:
+
+```bash
+cline
+```
+
+You'll see the Cline welcome screen. Type your task and press Enter. Use:
+- `Tab` to toggle between Plan and Act modes
+- `Shift+Tab` to enable auto-approve
+- `/help` for available commands
+
+[Learn more about interactive mode →](/cline-cli/interactive-mode)
+
+#### Direct Task Execution
+
+Run a task directly from your shell:
+
+```bash
+cline "Add error handling to utils.js"
+```
+
+For non-interactive execution (perfect for scripts and CI/CD):
+
+```bash
+cline -y "Run tests and fix any failures"
+```
+
+[Learn more about headless mode →](/cline-cli/three-core-flows)
+
+### Switching Providers
+
+To change your configured provider at any time:
+
+```bash
+cline auth
+```
+
+You can also use the settings panel in interactive mode:
+
+```bash
+cline
+# Then type: /settings
+# Navigate to the API tab
+```
+
+### Updating
+
+Check for updates and install the latest version:
+
+```bash
+cline update
+```
+
+Or update manually via npm:
+
+```bash
+npm update -g cline
+```
+
+### Troubleshooting
+
+#### Command Not Found
+
+If `cline` is not found after installation:
+
+1. Ensure npm global bin is in your PATH:
+   ```bash
+   npm bin -g
+   ```
+
+2. Add the path to your shell configuration (`.bashrc`, `.zshrc`, etc.):
+   ```bash
+   export PATH="$PATH:$(npm bin -g)"
+   ```
+
+3. Restart your terminal or source your shell config.
+
+#### Permission Errors
+
+If you get permission errors during installation:
+
+```bash
+# Option 1: Use a Node version manager (recommended)
+# nvm, fnm, or volta handle permissions automatically
+
+# Option 2: Fix npm permissions
+# See: https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally
+```
+
+#### OAuth Flow Issues
+
+If the browser doesn't open automatically during OAuth:
+1. Copy the URL from the terminal
+2. Paste it in your browser manually
+3. Complete the sign-in flow
+4. Return to the terminal
+
+#### API Key Validation
+
+If your API key is rejected:
+1. Verify the key is correct and hasn't expired
+2. Check that you've selected the correct provider
+3. Ensure your API account has the necessary permissions
+
+**Provider-specific tips:**
+- **Anthropic**: Keys start with `sk-ant-`
+- **OpenAI**: Keys start with `sk-`
+- **AWS Bedrock**: Requires AWS credentials configured separately. See [AWS Bedrock documentation](/provider-config/aws-bedrock/api-key).
+
+### Uninstallation
+
+To remove Cline CLI:
+
+```bash
+npm uninstall -g cline
+```
+
+To also remove configuration data:
+
+```bash
+rm -rf ~/.cline
+```
+
+## Next Steps
+
+- **[Interactive Mode](/cline-cli/interactive-mode)** - Master the interactive CLI with shortcuts and slash commands
+- **[Headless Mode](/cline-cli/three-core-flows)** - Run Cline autonomously in scripts, CI/CD pipelines, and automated workflows
+- **[Configuration](/cline-cli/configuration)** - Configure settings, rules, workflows, and environment variables
+- **[CLI Reference](/cline-cli/cli-reference)** - Complete command documentation with all flags and options

docs/cline-cli/installation.mdx

@@ -74,6 +74,9 @@ cline auth -p openai-native -k sk-xxxxx -m gpt-4o
 # OpenRouter
 cline auth -p openrouter -k sk-or-xxxxx -m anthropic/claude-sonnet-4-5-20250929
 
+# Moonshot
+cline auth -p moonshot -k sk-xxxxx -m kimi-k2.5
+
 # OpenAI-compatible provider with custom base URL
 cline auth -p openai -k your-api-key -b https://api.example.com/v1
 ```
@@ -82,7 +85,7 @@ cline auth -p openai -k your-api-key -b https://api.example.com/v1
 
 | Flag | Description |
 |------|-------------|
-| `-p, --provider <id>` | Provider ID (e.g., `anthropic`, `openai-native`, `openrouter`) |
+| `-p, --provider <id>` | Provider ID (e.g., `anthropic`, `openai-native`, `openrouter`, `moonshot`) |
 | `-k, --apikey <key>` | Your API key |
 | `-m, --modelid <id>` | Model ID (e.g., `claude-sonnet-4-5-20250929`, `gpt-4o`) |
 | `-b, --baseurl <url>` | Base URL for OpenAI-compatible providers |
@@ -104,6 +107,7 @@ Flags are especially useful for scripting, CI/CD environments, or setting up mul
 | X AI (Grok) | `xai` | Grok models |
 | Cerebras | `cerebras` | Fast inference |
 | DeepSeek | `deepseek` | DeepSeek models |
+| Moonshot | `moonshot` | Kimi models via Moonshot AI |
 | Ollama | `ollama` | Local models |
 | LM Studio | `lmstudio` | Local models |
 | OpenAI Compatible | `openai` | Any OpenAI-compatible API |
@@ -157,7 +161,7 @@ For non-interactive execution (perfect for scripts and CI/CD):
 cline -y "Run tests and fix any failures"
 ```
 
-[Learn more about CLI workflows →](/cline-cli/three-core-flows)
+[Learn more about headless mode →](/cline-cli/three-core-flows)
 
 ## Switching Providers
 
@@ -260,8 +264,8 @@ rm -rf ~/.cline
     Master the interactive CLI with shortcuts and slash commands.
   </Card>
   
-  <Card title="CLI Workflows" icon="route" href="/cline-cli/three-core-flows">
-    Learn interactive mode, direct execution, and automation patterns.
+  <Card title="Headless Mode" icon="robot" href="/cline-cli/three-core-flows">
+    Run Cline autonomously in scripts, CI/CD pipelines, and automated workflows.
   </Card>
   
   <Card title="Configuration" icon="gear" href="/cline-cli/configuration">

docs/cline-cli/interactive-mode.mdx

@@ -65,7 +65,7 @@ Keyboard shortcuts are the primary way to navigate and control the interactive C
 
 Reference files from your workspace by typing `@` followed by the filename:
 
-```
+```text
 @src/utils.ts can you add error handling to this file?
 ```
 
@@ -79,7 +79,7 @@ File search uses ripgrep for fast, fuzzy matching. You can type partial paths li
 
 Include multiple files in a single message:
 
-```
+```text
 Compare @src/old-api.ts with @src/new-api.ts and list the breaking changes
 ```
 
@@ -100,9 +100,9 @@ Type `/` to see available commands. Slash commands provide quick access to setti
 
 ### Workflow Commands
 
-If you have [workflows](/features/slash-commands/workflows/index) configured, they appear as additional slash commands. For example, if you have a workflow named `code-review`, you can invoke it with:
+If you have [workflows](/customization/workflows) configured, they appear as additional slash commands. For example, if you have a workflow named `code-review`, you can invoke it with:
 
-```
+```text
 /code-review
 ```
 
@@ -120,7 +120,7 @@ Access the settings panel with `/settings`. Navigate between tabs using arrow ke
 
 ## Plan and Act Modes
 
-Cline operates in two modes, toggled with `Tab`. These modes work the same way in the CLI as they do in the VS Code extension. For a deeper explanation of how Plan and Act modes work, see the [Plan and Act documentation](/features/plan-and-act).
+Cline operates in two modes, toggled with `Tab`. These modes work the same way in the CLI as they do in the VS Code extension. For a deeper explanation of how Plan and Act modes work, see the [Plan and Act documentation](/core-workflows/plan-and-act).
 
 ### Plan Mode
 
@@ -211,7 +211,7 @@ Use terminal multiplexers like tmux or split terminals to run multiple Cline ins
 
 Give Cline context about what you're working on:
 
-```
+```text
 I'm building a REST API with Express. The routes are in @src/routes/ and models in @src/models/. Help me add user authentication.
 ```
 
@@ -219,7 +219,7 @@ I'm building a REST API with Express. The routes are in @src/routes/ and models
 
 When you're unsure about the best approach:
 
-```
+```text
 [Tab to Plan mode]
 How should I structure the database schema for a multi-tenant SaaS app?
 ```
@@ -228,7 +228,7 @@ How should I structure the database schema for a multi-tenant SaaS app?
 
 The interactive CLI maintains conversation context. Build on previous messages:
 
-```
+```text
 > Add a login endpoint
 [Cline creates the endpoint]
 
@@ -242,8 +242,8 @@ The interactive CLI maintains conversation context. Build on previous messages:
 ## Next Steps
 
 <Columns cols={2}>
-  <Card title="CLI Workflows" icon="route" href="/cline-cli/three-core-flows">
-    Learn about interactive mode, direct execution, and automation patterns.
+  <Card title="Headless Mode" icon="robot" href="/cline-cli/three-core-flows">
+    Run Cline autonomously in scripts, CI/CD pipelines, and automated workflows.
   </Card>
   
   <Card title="Configuration" icon="gear" href="/cline-cli/configuration">

docs/cline-cli/overview.mdx

@@ -15,6 +15,15 @@ Ready to get started? Check out the [installation guide](/cline-cli/installation
 
 ## Two Ways to Use Cline CLI
 
+<Columns cols={2}>
+  <Card title="Interactive Mode" icon="terminal" href="/cline-cli/interactive-mode">
+    **For hands-on development.** Launch `cline` in your terminal and collaborate with Cline in real-time — chat, review plans, approve actions, and iterate on tasks with a rich visual interface.
+  </Card>
+  <Card title="Headless Mode" icon="robot" href="/cline-cli/three-core-flows">
+    **For automation & CI/CD.** Run `cline -y "task"` to let Cline work autonomously — no interaction needed. Pipe input/output, get JSON results, and chain commands in scripts and pipelines.
+  </Card>
+</Columns>
+
 The CLI operates in two distinct modes, automatically selecting the appropriate one based on how you invoke it:
 
 ### Interactive Mode
@@ -86,7 +95,7 @@ Cline automatically detects which mode to use based on your invocation. This tab
 | `cat file \| cline "task"` | Headless | stdin is piped |
 | `cline "task" > output.txt` | Headless | stdout is redirected |
 
-[Learn more about CLI workflows →](/cline-cli/three-core-flows)
+[Learn more about headless mode →](/cline-cli/three-core-flows)
 
 ## Supported Model Providers
 
@@ -198,6 +207,15 @@ Chains multiple Cline invocations together for creative multi-step workflows.
 | Session summary | ✓ | - |
 | JSON output | - | `--json` |
 | Piped input | - | ✓ |
+| [MCP servers](/cline-cli/configuration#mcp-server-configuration) | ✓ | ✓ |
+
+## MCP Server Support
+
+Cline CLI supports [MCP (Model Context Protocol)](/mcp/mcp-overview) servers, the same extensibility system available in the VS Code extension. MCP servers give Cline access to external tools and data sources, from databases and APIs to browser automation and project management.
+
+To use MCP servers with the CLI, add your server configuration to `~/.cline/data/settings/cline_mcp_settings.json`. The format is identical to the VS Code extension.
+
+[Configure MCP servers for the CLI →](/cline-cli/configuration#mcp-server-configuration)
 
 ## Learn More
 
@@ -210,8 +228,8 @@ Chains multiple Cline invocations together for creative multi-step workflows.
     Master the interactive CLI with keyboard shortcuts and slash commands.
   </Card>
   
-  <Card title="CLI Workflows" icon="route" href="/cline-cli/three-core-flows">
-    Learn interactive mode, direct execution, and automation patterns.
+  <Card title="Headless Mode" icon="robot" href="/cline-cli/three-core-flows">
+    Run Cline autonomously in scripts, CI/CD pipelines, and automated workflows.
   </Card>
   
   <Card title="Configuration" icon="gear" href="/cline-cli/configuration">
@@ -222,7 +240,7 @@ Chains multiple Cline invocations together for creative multi-step workflows.
     Run Cline as an ACP agent in JetBrains, Neovim, Zed, and more.
   </Card>
   
-  <Card title="Use in Other Editors" icon="code" href="/cline-cli/acp-editor-integrations">
-    Run Cline as an ACP agent in JetBrains, Neovim, Zed, and more.
+  <Card title="CLI Samples" icon="flask" href="/cline-cli/samples/overview">
+    Real-world examples of headless workflows and automation patterns.
   </Card>
 </Columns>

docs/cline-cli/samples/github-integration.mdx

@@ -3,8 +3,6 @@ title: "GitHub Actions Integration"
 description: "Automatically respond to GitHub issues by mentioning @cline in comments using Cline CLI in GitHub Actions."
 ---
 
-# GitHub Integration Sample
-
 Automate GitHub issue analysis with AI. Mention `@cline` in any issue comment to trigger an autonomous investigation that reads files, analyzes code, and provides actionable insights - all running automatically in GitHub Actions.
 
 
@@ -273,7 +271,7 @@ git push
 
 Once set up, simply mention `@cline` in any issue comment:
 
-```
+```text
 @cline what's causing this error?
 
 @cline analyze the root cause

docs/cline-cli/samples/github-issue-rca.mdx

@@ -3,8 +3,6 @@ title: "GitHub Issue RCA Sample"
 description: "Automated GitHub issue analysis using Cline CLI to identify root causes."
 ---
 
-# GitHub Root Cause Analysis
-
 Automated GitHub issue analysis using Cline CLI. This script uses Cline's autonomous AI capabilities to fetch, analyze, and identify root causes of GitHub issues, outputting clean, parseable results that can be easily integrated into your development workflows.
 
 <Note>
@@ -203,7 +201,7 @@ fi
 This is where the magic happens:
 
 ```bash
-# Ask Cline for his analysis, showing only the summary
+# Ask Cline for its analysis, showing only the summary
 cline -y "$PROMPT: $ISSUE_URL" --mode act $ADDRESS -F json | \
     sed -n '/^{/,$p' | \
     jq -r 'select(.say == "completion_result") | .text' | \
@@ -380,4 +378,4 @@ This pattern can be adapted for many other automation scenarios, from pull reque
 
 - [CLI Installation Guide](https://docs.cline.bot/cline-cli/installation)
 - [CLI Reference Documentation](https://docs.cline.bot/cline-cli/cli-reference)
-- [Three Core Flows](https://docs.cline.bot/cline-cli/three-core-flows)
+- [Headless Mode](https://docs.cline.bot/cline-cli/three-core-flows)

docs/cline-cli/samples/github-pr-review.mdx

@@ -3,14 +3,8 @@ title: "GitHub PR Review"
 description: "Automatically review Pull Requests with AI using Cline CLI in GitHub Actions."
 ---
 
-# GitHub PR Review Sample
-
 Automate code review for every Pull Request. Detailed analysis, security checks, and code suggestions provided by Cline running autonomously in GitHub Actions.
 
-<Frame>
-  <img src="https://storage.googleapis.com/cline_public_images/cli-pr-review.png" alt="Cline PR Review Comment" width="600" />
-</Frame>
-
 ## The Workflow
 
 When a PR is opened or marked ready for review, this workflow:

docs/cline-cli/samples/model-orchestration.mdx

@@ -3,26 +3,21 @@ title: "Model Orchestration"
 description: "Use multiple AI models strategically: optimize costs, reduce bias, and leverage model-specific strengths in your workflows"
 ---
 
-# Model Orchestration
-
 Cline CLI's `--config` and `--thinking` flags enable sophisticated multi-model workflows. Instead of using a single model for all tasks, you can route different work to different models based on cost, capability, and specialization.
 
 ## Why Orchestrate Multiple Models?
 
 **Cost Optimization**
-- Use fast, cheap models (Haiku, Gemini Flash) for simple tasks like summarization
-- Reserve expensive models (Opus, O1) for complex reasoning and planning
-- Reduce API costs by 10-100x on routine operations
+
+By routing work to the right model for the job, you can dramatically reduce API costs. Fast, inexpensive models like Haiku and Gemini Flash handle simple tasks such as summarization, while expensive models like Opus and O1 are reserved for complex reasoning and planning. This approach can reduce costs by 10-100x on routine operations.
 
 **Bias Reduction**
-- Different models catch different issues in code reviews
-- Cross-validate solutions with multiple AI perspectives
-- Reduce blind spots from single-model thinking
+
+Different models catch different issues, so cross-validating solutions with multiple AI perspectives helps reduce blind spots that come from relying on a single model. In code reviews especially, combining viewpoints surfaces problems that any one model might miss.
 
 **Specialization**
-- Some models excel at code (Codex, DeepSeek)
-- Others are better at documentation (GPT-4, Claude)
-- Security analysis benefits from multiple viewpoints
+
+Certain models excel in specific domains: Codex and DeepSeek are strong at code generation, while GPT-4 and Claude shine at documentation and prose. Security analysis in particular benefits from combining multiple model viewpoints, since each brings different training data and heuristics to the table.
 
 ## Pattern 1: CI/CD Code Review
 
@@ -213,8 +208,8 @@ cat *-sec.md | cline -y "find security issues all 3 reviews mentioned"
     Complete documentation for --config and --thinking flags
   </Card>
   
-  <Card title="Three Core Flows" icon="route" href="/cline-cli/three-core-flows">
-    Learn about interactive mode, headless automation, and multi-instance workflows
+  <Card title="Headless Mode" icon="robot" href="/cline-cli/three-core-flows">
+    Run Cline autonomously in scripts, CI/CD pipelines, and automated workflows.
   </Card>
   
   <Card title="Model Selection Guide" icon="brain" href="/core-features/model-selection-guide">

docs/cline-cli/samples/overview.mdx

@@ -53,4 +53,4 @@ This section provides sample implementations that demonstrate various Cline CLI
 
 - [CLI Installation Guide](/cline-cli/installation)
 - [CLI Reference Documentation](/cline-cli/cli-reference)
-- [Three Core Flows](/cline-cli/three-core-flows)
+- [Headless Mode](/cline-cli/three-core-flows)

docs/cline-cli/samples/worktree-workflows.mdx

@@ -3,8 +3,6 @@ title: "Worktree Workflows"
 description: "Use Git worktrees with Cline CLI to run parallel tasks, test different approaches, and pipe context between isolated environments"
 ---
 
-# Worktree Workflows
-
 Git worktrees let you have multiple branches checked out simultaneously in different folders. Combined with Cline CLI's `--cwd` flag, this enables powerful parallel development workflows and isolated experimentation.
 
 <Tip>
@@ -269,7 +267,7 @@ git worktree remove ~/cline-worktrees/feature-auth
     Complete documentation for --cwd and all other CLI flags
   </Card>
   
-  <Card title="Three Core Flows" icon="route" href="/cline-cli/three-core-flows">
-    Learn about interactive mode, task mode, and plain text workflows
+  <Card title="Headless Mode" icon="robot" href="/cline-cli/three-core-flows">
+    Run Cline autonomously in scripts, CI/CD pipelines, and automated workflows.
   </Card>
 </Columns>

docs/cline-cli/three-core-flows.mdx

@@ -1,134 +1,32 @@
 ---
-title: "CLI Workflows"
-description: "Learn the three ways to use Cline CLI: interactive mode, direct task execution, and automation"
+title: "Headless Mode"
+description: "Run Cline autonomously in scripts, CI/CD pipelines, and automated workflows"
 ---
 
-Cline CLI supports three primary workflows, each optimized for different use cases. Choose the approach that best fits your needs.
+Headless mode runs Cline without an interactive interface — perfect for automation, scripting, and CI/CD pipelines where human interaction isn't possible or desired. Cline executes tasks, produces clean text or JSON output, and exits when complete.
+
+For collaborative, conversational development, see [Interactive Mode](/cline-cli/interactive-mode) instead.
 
 <Note>
-**Migrating from an older CLI version?** Instance commands (`cline instance new/list/kill`) have been removed in Cline CLI 2.0. The new architecture is simpler. Just run `cline` for interactive mode or `cline "task"` for direct execution.
+**Migrating from an older CLI version?** Instance commands (`cline instance new/list/kill`) have been removed in Cline CLI 2.0. The new architecture is simpler — just use `cline -y "task"` for headless execution.
 </Note>
 
-## 1. Interactive Mode
+## When Headless Mode Activates
 
-The interactive CLI provides the richest experience for interactive development.
+Cline automatically enters headless mode when any of these conditions are met:
 
-### Getting Started
+| Invocation | Reason |
+|------------|--------|
+| `cline -y "task"` | `-y`/`--yolo` flag forces headless |
+| `cline --json "task"` | `--json` flag forces headless |
+| `cat file \| cline "task"` | stdin is piped |
+| `cline "task" > output.txt` | stdout is redirected |
 
-```bash
-cline
-```
+If none of these apply (e.g., running `cline` or `cline "task"` in a terminal), Cline launches in [interactive mode](/cline-cli/interactive-mode).
 
-This launches an interactive session in your current directory. Type your task, and Cline will analyze and execute it.
+## YOLO Mode (Fully Autonomous)
 
-### Key Features
-
-**Plan/Act Mode Toggle** - Press `Tab` to switch between modes:
-- **Plan Mode**: Cline analyzes your request and presents a strategy
-- **Act Mode**: Cline executes actions directly
-
-**Auto-approve Toggle** - Press `Shift+Tab` to enable automatic approval for all actions.
-
-**Slash Commands** - Type `/` for quick access to:
-- `/settings` - Configure providers, models, and features
-- `/models` - Quick model switching
-- `/history` - Browse and resume previous tasks
-- `/clear` - Start a fresh task
-- `/help` - Show available commands
-
-**File Mentions** - Type `@` to reference workspace files:
-```
-@src/utils.ts add error handling to this file
-```
-
-**Session Summary** - When you exit with `Ctrl+C`, Cline displays a summary of your session including tasks completed, files modified, and token usage.
-
-### When to Use Interactive Mode
-
-- Exploring a new codebase
-- Complex refactoring that requires back-and-forth
-- Learning how Cline approaches problems
-- Tasks where you want to review before executing
-
-[Full Interactive Mode Guide →](/cline-cli/interactive-mode)
-
-## 2. Direct Task Execution
-
-Execute tasks directly from the command line without entering interactive mode.
-
-### Basic Usage
-
-```bash
-cline "Add unit tests to utils.js"
-```
-
-Cline analyzes your task, creates a plan, and executes it. You'll be prompted for approval at key decision points.
-
-### Piping Context
-
-Pipe file contents or command output into Cline:
-
-```bash
-# Explain a file
-cat README.md | cline "Summarize this document"
-
-# Review git changes
-git diff | cline "Review these changes and suggest improvements"
-
-# Analyze command output
-npm test 2>&1 | cline "Analyze these test failures and fix them"
-```
-
-### Chaining Cline Commands
-
-Pipe Cline's output into another Cline instance for creative workflows:
-
-```bash
-# Explain changes, then write a commit message
-git diff | cline -y "explain these changes" | cline -y "write a commit message for this"
-
-# Generate code, then write tests
-cline -y "create a fibonacci function" | cline -y "write unit tests for this code"
-
-# Fun: Generate a poem about your code
-git diff | cline -y "explain" | cline -y "write a haiku about this"
-```
-
-### Including Images
-
-Attach images to your task:
-
-```bash
-cline task -i screenshot.png "Fix the layout issue shown in this screenshot"
-
-# Or reference inline
-cline "Fix the UI shown in @./design-mockup.png"
-```
-
-### Mode Selection
-
-```bash
-# Start in Plan mode (analyze before acting)
-cline -p "Design a REST API for user management"
-
-# Start in Act mode (default)
-cline -a "Fix the typo in README.md"
-```
-
-### When to Use Direct Execution
-
-- Quick, well-defined tasks
-- Tasks with sufficient context in the prompt
-- Scripting and shell workflows
-- When you don't need interactive conversation
-
-## 3. Automation & CI/CD
-
-For fully autonomous operation in scripts, CI/CD pipelines, and automated workflows.
-
-### YOLO Mode (Yes Mode)
-
-The `-y` or `--yolo` flag enables fully autonomous operation:
+The `-y` or `--yolo` flag enables fully autonomous operation — Cline approves all actions and runs without prompts:
 
 ```bash
 cline -y "Run the test suite and fix any failures"
@@ -141,12 +39,59 @@ In YOLO mode:
 - Perfect for CI/CD and scripts
 
 <Warning>
-Run YOLO mode on a clean git branch or directory. You get speed in exchange for oversight, so be ready to revert if needed.
+YOLO mode gives Cline full autonomy. Run on a clean git branch so you can easily revert changes if needed.
 </Warning>
 
-### JSON Output
+### Mode Selection
 
-Use `--json` for machine-readable output:
+Control whether Cline plans first or acts immediately:
+
+```bash
+# Start in Plan mode (analyze before acting)
+cline -y -p "Design a REST API for user management"
+
+# Start in Act mode (default)
+cline -y -a "Fix the typo in README.md"
+```
+
+## Piping Context
+
+Pipe file contents or command output into Cline to provide context:
+
+```bash
+# Explain a file
+cat README.md | cline "Summarize this document"
+
+# Review git changes
+git diff | cline "Review these changes and suggest improvements"
+
+# Analyze command output
+npm test 2>&1 | cline "Analyze these test failures and fix them"
+
+# Pipe a GitHub PR diff
+gh pr diff 123 | cline -y "Review this PR"
+```
+
+When stdin is piped, Cline automatically enters headless mode — the piped content becomes part of the task context.
+
+## Chaining Commands
+
+Pipe Cline's output into another Cline instance for multi-step workflows:
+
+```bash
+# Explain changes, then write a commit message
+git diff | cline -y "explain these changes" | cline -y "write a commit message for this"
+
+# Generate code, then write tests
+cline -y "create a fibonacci function" | cline -y "write unit tests for this code"
+
+# Fun: Generate a poem about your code
+git diff | cline -y "explain" | cline -y "write a haiku about this"
+```
+
+## JSON Output
+
+Use `--json` for machine-readable output that's easy to parse in scripts:
 
 ```bash
 cline --json "List all TODO comments in the codebase" | jq '.text'
@@ -164,25 +109,36 @@ JSON output follows the same format as task files in `~/.cline/data/tasks/<id>/u
 | `reasoning` | `string` | (Optional) Model reasoning |
 | `partial` | `boolean` | (Optional) Streaming flag |
 
-### Timeout Control
+## Including Images
 
-Set a maximum execution time:
+Attach images to your headless task:
+
+```bash
+cline -y -i screenshot.png "Fix the layout issue shown in this screenshot"
+
+# Or reference inline
+cline -y "Fix the UI shown in @./design-mockup.png"
+```
+
+## Timeout Control
+
+Set a maximum execution time to prevent runaway tasks:
 
 ```bash
 cline -y --timeout 600 "Run full test suite"
 ```
 
-### Environment Variables
+## Environment Variables
 
-Control Cline behavior via environment variables:
+Control Cline behavior via environment variables — useful for CI/CD where you can't use interactive configuration.
 
-**CLINE_DIR** - Custom configuration directory:
+**CLINE_DIR** — Custom configuration directory:
 ```bash
 export CLINE_DIR=/path/to/config
 cline -y "your task"
 ```
 
-**CLINE_COMMAND_PERMISSIONS** - Restrict allowed commands:
+**CLINE_COMMAND_PERMISSIONS** — Restrict allowed commands:
 ```bash
 export CLINE_COMMAND_PERMISSIONS='{"allow": ["npm *", "git *"], "deny": ["rm -rf *"]}'
 cline -y "your task"
@@ -190,6 +146,8 @@ cline -y "your task"
 
 See [Configuration](/cline-cli/configuration#environment-variables) for full documentation.
 
+## CI/CD Integration
+
 ### GitHub Actions Example
 
 Automate PR reviews with Cline:
@@ -232,7 +190,7 @@ jobs:
 
 ### Shell Script Example
 
-Create a code review script:
+Create a reusable code review script:
 
 ```bash
 #!/bin/bash
@@ -252,30 +210,24 @@ fi
 echo "$DIFF" | cline -y --json "Review this code diff for issues" | jq -r '.text'
 ```
 
-### When to Use Automation Mode
+## Common Use Cases
 
-- CI/CD pipelines
-- Scheduled maintenance tasks
-- Batch processing
-- Any workflow requiring non-interactive execution
-
-## Choosing the Right Flow
-
-| Use Case | Recommended Flow |
-|----------|------------------|
-| Exploring a new codebase | Interactive Mode |
-| Complex refactoring | Interactive Mode (Plan first) |
-| Quick file edits | Direct Execution |
-| Code review | Direct Execution with pipe |
-| CI/CD integration | Automation (`-y` flag) |
-| Scheduled tasks | Automation (`-y` flag) |
-| Learning Cline | Interactive Mode |
+| Use Case | Example |
+|----------|---------|
+| Code review | `git diff \| cline -y "Review these changes"` |
+| Fix test failures | `cline -y "Run tests and fix any failures"` |
+| Generate release notes | `git log --oneline v1.0..v1.1 \| cline -y "Write release notes"` |
+| Fix lint errors | `cline -y "Fix all ESLint errors in src/"` |
+| Update dependencies | `cline -y "Update dependencies with known vulnerabilities"` |
+| Migrate code patterns | `cline -y "Update all deprecated React lifecycle methods"` |
+| PR automation | `gh pr diff 123 \| cline -y "Review this PR"` |
+| Batch processing | `cline -y --json "List all TODO comments" \| jq '.text'` |
 
 ## Next Steps
 
 <Columns cols={2}>
   <Card title="Interactive Mode" icon="terminal" href="/cline-cli/interactive-mode">
-    Master keyboard shortcuts, slash commands, and file mentions.
+    For hands-on development with keyboard shortcuts, slash commands, and file mentions.
   </Card>
   
   <Card title="CLI Reference" icon="book" href="/cline-cli/cli-reference">
@@ -286,7 +238,7 @@ echo "$DIFF" | cline -y --json "Review this code diff for issues" | jq -r '.text
     Environment variables, rules, and advanced settings.
   </Card>
   
-  <Card title="YOLO Mode" icon="zap" href="/features/yolo-mode">
-    Deep dive into autonomous execution and safety considerations.
+  <Card title="CLI Samples" icon="flask" href="/cline-cli/samples/overview">
+    Real-world examples of headless workflows and automation patterns.
   </Card>
 </Columns>

docs/cline-sdk/overview.md

@@ -0,0 +1,643 @@
+# Cline SDK
+
+The Cline SDK lets you embed Cline as a programmable coding agent in your Node.js applications. It exposes the same capabilities as the Cline CLI and VS Code extension — file editing, command execution, browser use, MCP servers — through a TypeScript API that conforms to the [Agent Client Protocol (ACP)](https://agentclientprotocol.com/protocol/schema).
+
+## Installation
+
+```bash
+npm install cline
+```
+
+If you want direct ACP type imports as well:
+
+```bash
+npm install @agentclientprotocol/sdk
+```
+
+Requires Node.js 20+.
+
+## Quick Start
+
+```typescript
+import { ClineAgent } from "cline"
+
+const agent = new ClineAgent({ version: "1.0.0" })
+
+// 1. Initialize — negotiates capabilities
+await agent.initialize({
+  protocolVersion: 1,
+  clientCapabilities: {},
+})
+
+// 2. Authenticate (if using Cline-hosted models)
+await agent.authenticate({ methodId: "cline-oauth" })
+
+// 3. Create a session
+const { sessionId } = await agent.newSession({
+  cwd: process.cwd(),
+  mcpServers: [],
+})
+
+// 4. Subscribe to streaming output
+const emitter = agent.emitterForSession(sessionId)
+
+emitter.on("agent_message_chunk", (payload) => {
+  process.stdout.write(payload.content.text)
+})
+
+emitter.on("tool_call", (payload) => {
+  console.log(`[tool] ${payload.title}`)
+})
+
+emitter.on("error", (err) => {
+  console.error("[session error]", err)
+})
+
+// 5. Send a prompt and wait for completion
+const { stopReason } = await agent.prompt({
+  sessionId,
+  prompt: [{ type: "text", text: "Create a hello world Express server" }],
+})
+
+console.log("Done:", stopReason)
+
+// 6. Clean up
+await agent.shutdown()
+```
+
+## Core Concepts
+
+### Agent Lifecycle
+
+The SDK follows the ACP lifecycle:
+
+```
+initialize() → authenticate() → newSession() → prompt() ⇄ events → shutdown()
+```
+
+| Step | Method | Purpose |
+|------|--------|---------|
+| Init | `initialize()` | Exchange protocol version and capabilities |
+| Auth | `authenticate()` | OAuth flow for Cline or OpenAI Codex accounts |
+| Session | `newSession()` | Create an isolated conversation context |
+| Prompt | `prompt()` | Send user messages; blocks until the turn ends |
+| Cancel | `cancel()` | Abort an in-progress prompt turn |
+| Mode | `setSessionMode()` | Switch between `"plan"` and `"act"` modes |
+| Model | `unstable_setSessionModel()` | Change the backing LLM (experimental) |
+| Shutdown | `shutdown()` | Abort all tasks, flush state, release resources |
+
+### Sessions
+
+A session is an independent conversation with its own task history, working directory, and MCP server connections. You can run multiple sessions concurrently.
+
+```typescript
+const { sessionId, modes, models } = await agent.newSession({
+  cwd: "/path/to/project",
+  mcpServers: [
+    { name: "my-server", command: "npx", args: ["-y", "my-mcp-server"] },
+  ],
+})
+```
+
+The response includes:
+- `sessionId` — use this in all subsequent calls
+- `modes` — available modes (`plan`, `act`) and the current mode
+- `models` — available models and the current model ID
+
+Access session metadata via the read-only `sessions` map:
+
+```typescript
+const session = agent.sessions.get(sessionId)
+// { sessionId, cwd, mode, mcpServers, createdAt, lastActivityAt, ... }
+```
+
+### Prompting
+
+`prompt()` sends a user message and blocks until the agent finishes its turn. While the prompt is processing, the agent streams output via session events.
+
+```typescript
+const response = await agent.prompt({
+  sessionId,
+  prompt: [
+    { type: "text", text: "Refactor the auth module to use JWT" },
+  ],
+})
+```
+
+The prompt array accepts multiple content blocks:
+
+```typescript
+// Text + image + file context
+await agent.prompt({
+  sessionId,
+  prompt: [
+    { type: "text", text: "What's in this screenshot?" },
+    { type: "image", data: base64ImageData, mimeType: "image/png" },
+    {
+      type: "resource",
+      resource: {
+        uri: "file:///path/to/relevant-file.ts",
+        mimeType: "text/plain",
+        text: fileContents,
+      },
+    },
+  ],
+})
+```
+
+#### Content Block Types
+
+| Type | Fields | Description |
+|------|--------|-------------|
+| `TextContent` | `{ type: "text", text: string }` | Plain text message |
+| `ImageContent` | `{ type: "image", mimeType: string, data: string }` | Base64-encoded image |
+| `EmbeddedResource` | `{ type: "resource", resource: { uri: string, mimeType?: string, text?: string, blob?: string } }` | File or resource context |
+
+#### Stop Reasons
+
+`prompt()` resolves with a `stopReason`:
+
+| Value | Meaning |
+|-------|---------|
+| `"end_turn"` | Agent finished normally (completed task or waiting for user input) |
+| `"cancelled"` | You called `cancel()` during the turn |
+| `"error"` | An unrecoverable error occurred |
+| `"max_tokens"` | Context window exhausted |
+
+### Streaming Events
+
+Subscribe to real-time output via `ClineSessionEmitter`. Each session has its own emitter.
+
+```typescript
+const emitter = agent.emitterForSession(sessionId)
+```
+
+#### Event Types
+
+All events correspond to [ACP `SessionUpdate` types](https://agentclientprotocol.com/protocol/schema#SessionUpdate):
+
+| Event | Payload | Description |
+|-------|---------|-------------|
+| `agent_message_chunk` | `{ content: ContentBlock }` | Streamed text from the agent |
+| `agent_thought_chunk` | `{ content: ContentBlock }` | Internal reasoning / chain-of-thought |
+| `tool_call` | `ToolCall` | New tool invocation (file edit, command, etc.) |
+| `tool_call_update` | `ToolCallUpdate` | Progress/result update for an existing tool call |
+| `plan` | `{ entries: PlanEntry[] }` | Agent's execution plan |
+| `available_commands_update` | `{ availableCommands: AvailableCommand[] }` | Slash commands the agent supports |
+| `current_mode_update` | `{ currentModeId: string }` | Mode changed (plan/act) |
+| `user_message_chunk` | `{ content: ContentBlock }` | User message chunks (for multi-turn) |
+| `config_option_update` | `{ configOptions: SessionConfigOption[] }` | Configuration changed |
+| `session_info_update` | Session metadata | Session metadata changed |
+| `error` | `Error` | Session-level error (not an ACP update) |
+
+```typescript
+emitter.on("agent_message_chunk", (payload) => {
+  // payload.content is a ContentBlock — usually { type: "text", text: "..." }
+  process.stdout.write(payload.content.text)
+})
+
+emitter.on("agent_thought_chunk", (payload) => {
+  console.log("[thinking]", payload.content.text)
+})
+
+emitter.on("tool_call", (payload) => {
+  console.log(`[${payload.kind}] ${payload.title} (${payload.status})`)
+})
+
+emitter.on("tool_call_update", (payload) => {
+  console.log(`  → ${payload.toolCallId}: ${payload.status}`)
+})
+
+emitter.on("error", (err) => {
+  console.error("Session error:", err)
+})
+```
+
+The emitter supports `on`, `once`, `off`, and `removeAllListeners`.
+
+### Permission Handling
+
+When the agent wants to execute a tool (edit a file, run a command, etc.), it requests permission. You **must** set a permission handler or all tool calls will be auto-rejected.
+
+```typescript
+agent.setPermissionHandler((request, resolve) => {
+  // request.toolCall — details about what the agent wants to do
+  // request.options — available choices (allow_once, reject_once, etc.)
+
+  console.log(`Permission requested: ${request.toolCall.title}`)
+  console.log("Options:", request.options.map(o => `${o.optionId} (${o.kind})`))
+
+  // Auto-approve everything:
+  const allowOption = request.options.find(o => o.kind === "allow_once")
+  if (allowOption) {
+    resolve({ outcome: { outcome: "selected", optionId: allowOption.optionId } })
+  } else {
+    resolve({ outcome: { outcome: "rejected" } })
+  }
+})
+```
+
+#### Permission Options
+
+Each permission request includes an array of `PermissionOption` objects:
+
+| `kind` | Meaning |
+|--------|---------|
+| `allow_once` | Approve this single operation |
+| `allow_always` | Approve and remember for future operations |
+| `reject_once` | Deny this single operation |
+| `reject_always` | Deny and remember for future operations |
+
+**Important:** If no permission handler is set, all tool calls are rejected for safety.
+
+### Modes
+
+Cline supports two modes:
+
+- **`plan`** — The agent gathers information and creates a plan without executing actions
+- **`act`** — The agent executes actions (file edits, commands, etc.)
+
+```typescript
+// Switch to plan mode
+await agent.setSessionMode({ sessionId, modeId: "plan" })
+
+// Switch back to act mode
+await agent.setSessionMode({ sessionId, modeId: "act" })
+```
+
+The current mode is returned in `newSession()` and emitted via `current_mode_update` events.
+
+### Model Selection
+
+Change the backing model with `unstable_setSessionModel()`. The model ID format is `"provider/modelId"`.
+
+```typescript
+await agent.unstable_setSessionModel({
+  sessionId,
+  modelId: "anthropic/claude-sonnet-4-20250514",
+})
+```
+
+This sets the model for both plan and act modes. Available providers include `anthropic`, `openai-native`, `gemini`, `bedrock`, `deepseek`, `mistral`, `groq`, `xai`, and others.
+
+> **Note:** This API is experimental and may change.
+
+### Authentication
+
+The SDK supports two OAuth flows:
+
+```typescript
+// Cline account (uses browser OAuth)
+await agent.authenticate({ methodId: "cline-oauth" })
+
+// OpenAI Codex / ChatGPT subscription
+await agent.authenticate({ methodId: "openai-codex-oauth" })
+```
+
+Both methods open a browser window for the OAuth flow and block until authentication completes (5-minute timeout for Cline OAuth).
+
+For BYO (bring-your-own) API key providers, configure the key through the state manager before creating a session. The `authenticate()` call is not needed for BYO providers.
+
+### Cancellation
+
+Cancel an in-progress prompt turn:
+
+```typescript
+await agent.cancel({ sessionId })
+```
+
+The pending `prompt()` call will resolve with `{ stopReason: "cancelled" }`.
+
+## API Reference
+
+### Constructor
+
+```typescript
+new ClineAgent(options: ClineAgentOptions)
+```
+
+```typescript
+interface ClineAgentOptions {
+  /** Version string for your application (required) */
+  version: string
+  /** Enable debug logging (default: false) */
+  debug?: boolean
+  /** Custom Cline config directory (default: ~/.cline) */
+  clineDir?: string
+}
+```
+
+The `clineDir` option lets you isolate configuration and task history per-application:
+
+```typescript
+const agent = new ClineAgent({
+  version: "1.0.0",
+  clineDir: "/tmp/my-app-cline",
+})
+```
+
+### Methods
+
+#### `initialize(params): Promise<InitializeResponse>`
+
+Initialize the agent and negotiate protocol capabilities.
+
+```typescript
+const response = await agent.initialize({
+  clientCapabilities: {},
+  protocolVersion: 1,
+})
+
+// Response includes:
+{
+  protocolVersion: "0.9.0",
+  agentCapabilities: {
+    loadSession: true,
+    promptCapabilities: { image: true, audio: false, embeddedContext: true },
+    mcpCapabilities: { http: true, sse: false }
+  },
+  agentInfo: { name: "cline", version: "2.2.3" },
+  authMethods: [
+    { id: "cline-oauth", name: "Sign in with Cline", description: "..." },
+    { id: "openai-codex-oauth", name: "Sign in with ChatGPT", description: "..." }
+  ]
+}
+```
+
+#### `newSession(params): Promise<NewSessionResponse>`
+
+Create a new conversation session.
+
+```typescript
+const session = await agent.newSession({
+  cwd: "/path/to/project",
+  mcpServers: [
+    {
+      type: "stdio",
+      name: "filesystem",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"],
+      env: {},
+    },
+  ],
+})
+
+// Response includes:
+{
+  sessionId: "uuid-string",
+  modes: {
+    availableModes: [
+      { id: "plan", name: "Plan", description: "Gather information and create a detailed plan" },
+      { id: "act", name: "Act", description: "Execute actions to accomplish the task" }
+    ],
+    currentModeId: "act"
+  },
+  models: {
+    currentModelId: "anthropic/claude-sonnet-4-5-20241022",
+    availableModels: [{ modelId: "anthropic/claude-3-5-sonnet-20241022", name: "..." }]
+  }
+}
+```
+
+> **Note:** `newSession()` may throw an auth-required error if credentials are not configured yet.
+
+#### `prompt(params): Promise<PromptResponse>`
+
+Send a user prompt to the agent. This is the main method for interacting with Cline. Blocks until the agent finishes its turn.
+
+```typescript
+const response = await agent.prompt({
+  sessionId: session.sessionId,
+  prompt: [
+    { type: "text", text: "Create a function that adds two numbers" },
+  ],
+})
+
+// Response: { stopReason: "end_turn" | "max_tokens" | "cancelled" | "error" }
+```
+
+#### `cancel(params): Promise<void>`
+
+Cancel an ongoing prompt operation.
+
+```typescript
+await agent.cancel({ sessionId: session.sessionId })
+```
+
+#### `setSessionMode(params): Promise<SetSessionModeResponse>`
+
+Switch between plan and act modes.
+
+```typescript
+await agent.setSessionMode({ sessionId, modeId: "plan" })
+```
+
+#### `unstable_setSessionModel(params): Promise<SetSessionModelResponse>`
+
+Change the model for the session. Model ID format: `"provider/modelId"`.
+
+```typescript
+await agent.unstable_setSessionModel({
+  sessionId,
+  modelId: "anthropic/claude-sonnet-4-20250514",
+})
+```
+
+#### `authenticate(params): Promise<AuthenticateResponse>`
+
+Authenticate with a provider. Opens a browser window for OAuth flow.
+
+```typescript
+await agent.authenticate({ methodId: "cline-oauth" })
+```
+
+#### `shutdown(): Promise<void>`
+
+Clean up all resources. Call this when done.
+
+```typescript
+await agent.shutdown()
+```
+
+#### `setPermissionHandler(handler)`
+
+Set a callback to handle tool permission requests.
+
+```typescript
+agent.setPermissionHandler((request, resolve) => {
+  resolve({ outcome: { outcome: "selected", optionId: "allow_once" } })
+})
+```
+
+#### `emitterForSession(sessionId): ClineSessionEmitter`
+
+Get the typed event emitter for a session.
+
+```typescript
+const emitter = agent.emitterForSession(session.sessionId)
+```
+
+#### `sessions` (read-only Map)
+
+Access active sessions:
+
+```typescript
+for (const [sessionId, session] of agent.sessions) {
+  console.log(sessionId, session.cwd, session.mode)
+}
+```
+
+## Full Example: Auto-Approve Agent
+
+```typescript
+import { ClineAgent } from "cline"
+
+async function runTask(task: string, cwd: string) {
+  const agent = new ClineAgent({ version: "1.0.0" })
+
+  await agent.initialize({
+    protocolVersion: 1,
+    clientCapabilities: {},
+  })
+
+  const { sessionId } = await agent.newSession({ cwd, mcpServers: [] })
+
+  // Auto-approve all tool calls
+  agent.setPermissionHandler((request, resolve) => {
+    const allow = request.options.find(o => o.kind === "allow_once")
+    resolve({
+      outcome: allow
+        ? { outcome: "selected", optionId: allow.optionId }
+        : { outcome: "rejected" },
+    })
+  })
+
+  // Collect output
+  const output: string[] = []
+  const emitter = agent.emitterForSession(sessionId)
+
+  emitter.on("agent_message_chunk", (p) => {
+    if (p.content.type === "text") output.push(p.content.text)
+  })
+
+  emitter.on("tool_call", (p) => {
+    console.log(`[tool] ${p.title}`)
+  })
+
+  const { stopReason } = await agent.prompt({
+    sessionId,
+    prompt: [{ type: "text", text: task }],
+  })
+
+  console.log("\n--- Agent Output ---")
+  console.log(output.join(""))
+  console.log(`\nStop reason: ${stopReason}`)
+
+  await agent.shutdown()
+}
+
+runTask("Create a README.md for this project", process.cwd())
+```
+
+## Full Example: Interactive Permission Flow
+
+```typescript
+import { ClineAgent, type PermissionHandler } from "cline"
+import * as readline from "readline"
+
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+const ask = (q: string) => new Promise<string>((res) => rl.question(q, res))
+
+const interactivePermissions: PermissionHandler = async (request, resolve) => {
+  console.log(`\n⚠️  Permission: ${request.toolCall.title}`)
+
+  for (const [i, opt] of request.options.entries()) {
+    console.log(`  ${i + 1}. [${opt.kind}] ${opt.name}`)
+  }
+
+  const choice = await ask("Choose (number): ")
+  const idx = parseInt(choice, 10) - 1
+  const selected = request.options[idx]
+
+  if (selected) {
+    resolve({ outcome: { outcome: "selected", optionId: selected.optionId } })
+  } else {
+    resolve({ outcome: { outcome: "rejected" } })
+  }
+}
+
+async function main() {
+  const agent = new ClineAgent({ version: "1.0.0" })
+  await agent.initialize({ protocolVersion: 1, clientCapabilities: {} })
+
+  const { sessionId } = await agent.newSession({
+    cwd: process.cwd(),
+    mcpServers: [],
+  })
+
+  agent.setPermissionHandler(interactivePermissions)
+
+  const emitter = agent.emitterForSession(sessionId)
+  emitter.on("agent_message_chunk", (p) => {
+    if (p.content.type === "text") process.stdout.write(p.content.text)
+  })
+
+  // Multi-turn conversation
+  while (true) {
+    const userInput = await ask("\n> ")
+    if (userInput === "exit") break
+
+    const { stopReason } = await agent.prompt({
+      sessionId,
+      prompt: [{ type: "text", text: userInput }],
+    })
+
+    console.log(`\n[${stopReason}]`)
+  }
+
+  await agent.shutdown()
+  rl.close()
+}
+
+main()
+```
+
+## Exported Types
+
+All types are re-exported from the `cline` package. Key types:
+
+| Type | Description |
+|------|-------------|
+| `ClineAgent` | Main agent class |
+| `ClineSessionEmitter` | Typed event emitter for session events |
+| `ClineAgentOptions` | Constructor options |
+| `ClineAcpSession` | Session metadata (read-only) |
+| `ClineSessionEvents` | Event name → handler signature map |
+| `PermissionHandler` | `(request, resolve) => void` callback |
+| `PermissionResolver` | `(response) => void` callback |
+| `SessionUpdate` | Union of all session update types |
+| `SessionUpdateType` | Discriminator values (`"agent_message_chunk"`, `"tool_call"`, etc.) |
+| `ToolCall` | Tool call details (id, title, kind, status, content) |
+| `ToolCallUpdate` | Partial update to an existing tool call |
+| `ToolCallStatus` | `"pending" \| "in_progress" \| "completed" \| "failed"` |
+| `ToolKind` | `"read" \| "edit" \| "delete" \| "execute" \| "search" \| ...` |
+| `StopReason` | `"end_turn" \| "cancelled" \| "error" \| "max_tokens" \| ...` |
+| `ContentBlock` | `TextContent \| ImageContent \| AudioContent \| ...` |
+| `McpServer` | MCP server configuration (stdio, http) |
+| `PromptRequest` / `PromptResponse` | Prompt call types |
+| `NewSessionRequest` / `NewSessionResponse` | Session creation types |
+| `InitializeRequest` / `InitializeResponse` | Initialization types |
+
+See the [ACP Schema](https://agentclientprotocol.com/protocol/schema) for the full type definitions.
+
+## Relationship to ACP
+
+The Cline SDK implements the [Agent Client Protocol](https://agentclientprotocol.com) `Agent` interface. The key difference from a standard ACP stdio agent is that the SDK uses an **event emitter pattern** instead of a transport connection:
+
+| ACP Stdio (via `AcpAgent`) | SDK (via `ClineAgent`) |
+|-----------------------------|------------------------|
+| Session updates sent over JSON-RPC stdio | Session updates emitted via `ClineSessionEmitter` |
+| Permissions requested via `connection.requestPermission()` | Permissions requested via `setPermissionHandler()` callback |
+| Single process, single connection | Embeddable, multiple concurrent sessions |
+
+If you need stdio-based ACP communication (e.g., for IDE integration), use the `cline` CLI binary directly. The SDK is for embedding Cline in your own Node.js processes.

docs/contributing/doc-templates.mdx

@@ -0,0 +1,316 @@
+---
+title: "Documentation Templates"
+sidebarTitle: "Templates"
+description: "Templates for different types of Cline documentation"
+---
+
+Use these templates as starting points for new documentation. Each template is designed for a specific purpose. Choose the one that best fits what you're documenting.
+
+## Choosing a Template
+
+| If you're documenting... | Use this template |
+|--------------------------|-------------------|
+| What a feature does and how to use it | Feature Doc |
+| How to accomplish a specific task | How-To Guide |
+| Technical specifications or API details | Reference Doc |
+| A complete project walkthrough | Tutorial |
+
+## Feature Doc
+
+Use this template when explaining a Cline feature. Focus on what it does, how to use it, and real examples.
+
+````text
+---
+title: "Feature Name"
+sidebarTitle: "Feature Name"
+---
+
+[One sentence explaining what this feature does.]
+
+<Frame>
+  <img src="..." alt="Feature in action" />
+</Frame>
+
+[1-2 paragraphs explaining the feature in plain terms. What problem does it 
+solve? Why would someone use it?]
+
+## How It Works
+
+[Explain the mechanics without jargon. What happens when you use this feature?]
+
+## Using [Feature Name]
+
+[Show how to access and use it. Include the exact UI path.]
+
+### [Option or Variation 1]
+
+[Details with examples]
+
+### [Option or Variation 2]
+
+[Details with examples]
+
+## Inspiration
+
+[Share how you personally use this feature. Use "I" voice. Give 2-3 real 
+examples that spark imagination about what's possible.]
+
+<Note>
+  [Important caveat, limitation, or requirement]
+</Note>
+````
+
+### Example: Checkpoints Feature
+
+Here's how the [Checkpoints](/core-workflows/checkpoints) doc follows this pattern:
+
+- Opens with one clear sentence about what checkpoints do
+- Shows a screenshot of the feature in action
+- Explains how checkpoints work under the hood
+- Shows exact steps to create and restore checkpoints
+- Includes real examples of when checkpoints save the day
+
+## How-To Guide
+
+Use this template when showing how to accomplish a specific task. Focus on clear steps and troubleshooting.
+
+````text
+---
+title: "How to [Accomplish Task]"
+sidebarTitle: "[Short Title]"
+description: "[One sentence describing what the reader will learn]"
+---
+
+[Brief intro explaining what problem this guide solves and what you'll end up 
+with after following it.]
+
+## Prerequisites
+
+[What the reader needs before starting. Keep it short. Link to other docs 
+rather than explaining setup here.]
+
+- Cline installed and configured
+- [Other requirement]
+
+## Steps
+
+<Steps>
+  <Step title="[First Action]">
+    [Clear instructions. Show exactly what to click or type.]
+    
+    ```bash
+    example command if needed
+    ```
+  </Step>
+  <Step title="[Second Action]">
+    [Next step. Include screenshots for complex UI interactions.]
+    
+    <Frame>
+      <img src="..." alt="What you should see" />
+    </Frame>
+  </Step>
+  <Step title="[Final Action]">
+    [Complete the task. Show the expected result.]
+  </Step>
+</Steps>
+
+## Troubleshooting
+
+Common issues and how to fix them:
+
+- **Problem description**: Solution in one or two sentences.
+- **Another problem**: Another solution.
+
+## Next Steps
+
+<Card title="Related Feature" icon="arrow-right" href="/path/to/related">
+  Continue learning with this related guide.
+</Card>
+````
+
+### Example: Your First Project
+
+The [Your First Project](/getting-started/your-first-project) guide follows this pattern:
+
+- Clear goal stated upfront
+- Prerequisites listed briefly
+- Step-by-step instructions with the Steps component
+- Troubleshooting section for common issues
+
+## Reference Doc
+
+Use this template for technical specifications, API documentation, or detailed configuration options.
+
+````text
+---
+title: "[Component/API] Reference"
+sidebarTitle: "[Short Title]"
+description: "[What this reference covers]"
+---
+
+[Brief description of what this reference documents and when you'd need it.]
+
+## Overview
+
+[High-level explanation. What is this component? What role does it play?]
+
+## [Category 1]
+
+### [Item Name]
+
+[What it does in one sentence.]
+
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| `propertyName` | `string` | `"default"` | What this property controls |
+| `anotherProp` | `boolean` | `false` | What this does |
+
+**Example:**
+
+```typescript
+// Show practical usage
+const example = {
+  propertyName: "custom value",
+  anotherProp: true
+}
+```
+
+### [Another Item]
+
+[Continue for each item in this category.]
+
+## [Category 2]
+
+[Continue with other categories as needed.]
+
+## Examples
+
+[Show 2-3 complete, practical examples that combine multiple concepts.]
+
+### [Example 1 Title]
+
+```typescript
+// Complete working example
+```
+
+### [Example 2 Title]
+
+```typescript
+// Another complete example
+```
+
+## Related
+
+- [Related Doc 1](/path/to/doc) - Brief description
+- [Related Doc 2](/path/to/doc) - Brief description
+````
+
+### Example: Cline Tools Guide
+
+The [Cline Tools Guide](/tools-reference/all-cline-tools) follows this pattern:
+
+- Overview of the tool system
+- Each tool documented with parameters and examples
+- Practical examples showing tools in context
+
+## Tutorial
+
+Use this template for comprehensive project walkthroughs where users build something from start to finish.
+
+````text
+---
+title: "[Build/Create X] Tutorial"
+sidebarTitle: "[Short Title]"
+description: "[What the reader will build]"
+---
+
+In this tutorial, you'll build [specific outcome]. By the end, you'll have 
+[tangible result you can see/use].
+
+<Frame>
+  <img src="..." alt="Preview of what you'll build" />
+</Frame>
+
+## What You'll Learn
+
+- [Skill or concept 1]
+- [Skill or concept 2]
+- [Skill or concept 3]
+
+## Prerequisites
+
+[Required setup. Link to installation guides rather than repeating them.]
+
+- [Prerequisite 1]
+- [Prerequisite 2]
+
+## Part 1: [First Major Section]
+
+[Introduction to this section. What are we doing and why?]
+
+### [Subsection]
+
+[Detailed walkthrough with code blocks and explanations.]
+
+```typescript
+// Code that the reader should write or understand
+```
+
+[Explain what the code does and why.]
+
+## Part 2: [Second Major Section]
+
+[Continue building on Part 1.]
+
+### [Subsection]
+
+[More detailed walkthrough.]
+
+## Part 3: [Final Section]
+
+[Complete the project.]
+
+## Summary
+
+You built [what they built]. Along the way, you learned:
+
+- [Key takeaway 1]
+- [Key takeaway 2]
+- [Key takeaway 3]
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Go Deeper" icon="book" href="/path/to/advanced">
+    Learn more advanced techniques.
+  </Card>
+  <Card title="Related Tutorial" icon="code" href="/path/to/related">
+    Build something else with similar concepts.
+  </Card>
+</CardGroup>
+````
+
+### Example Structure
+
+A good tutorial:
+- Shows the end result upfront so readers know what they're building
+- Breaks the work into logical parts
+- Explains the "why" alongside the "how"
+- Ends with clear next steps
+
+## Quick Tips
+
+When using these templates:
+
+1. **Delete sections you don't need.** Templates are starting points, not rigid structures.
+
+2. **Add sections that make sense.** If your doc needs something not in the template, add it.
+
+3. **Keep the reader moving forward.** Every section should lead naturally to the next.
+
+4. **Test your own instructions.** Follow your guide from scratch to catch missing steps.
+
+<Tip>
+  Use the `/write-docs` workflow to generate documentation from these templates automatically. 
+  Cline helps you fill in each section based on your project.
+</Tip>

docs/contributing/documentation-guide.mdx

@@ -0,0 +1,200 @@
+---
+title: "Documentation Guide"
+sidebarTitle: "Documentation Guide"
+description: "How to write and contribute to Cline documentation"
+---
+
+Cline's documentation lives in the `docs/` directory and uses [Mintlify](https://mintlify.com) for rendering. This guide covers how to write docs that match Cline's established style.
+
+## Using the Documentation Workflow
+
+The fastest way to create documentation is using the `/write-docs` workflow. Type `/write-docs` in Cline and describe what you want to document. Cline guides you through a 4-step process:
+
+1. **Research**: Examine existing docs structure and patterns
+2. **Scope**: Clarify audience, doc type, and key use cases
+3. **Outline**: Select a template and create structure
+4. **Write**: Generate documentation following style guidelines
+
+The workflow file lives at `.clinerules/workflows/write-docs.md` and contains templates, style rules, and examples.
+
+## Documentation Principles
+
+### Write for Developers
+
+Your audience is developers who value their time. Get to the point. Every sentence should either help them understand something or help them do something.
+
+```markdown
+# Good
+Switch to bash in Cline Settings → Terminal → Default Terminal Profile.
+
+# Bad
+Users who are experiencing issues may find it helpful to navigate to the 
+Cline settings menu where they can locate the terminal configuration 
+options and subsequently modify the default terminal profile setting.
+```
+
+### Show Real Examples
+
+Abstract descriptions don't help anyone. Show actual code, real file paths, and concrete implementations.
+
+```markdown
+# Good
+I use `/deep-planning` whenever I'm building features that touch multiple 
+parts of the codebase. For example, when adding authentication, Cline 
+mapped every endpoint and created a migration plan that avoided breaking changes.
+
+# Bad
+The deep planning feature can be utilized for various complex tasks 
+that may require careful consideration and planning.
+```
+
+### Use Active Voice
+
+Cline does things. Files don't get created by Cline, Cline creates files.
+
+```markdown
+# Good
+Cline reads your project files and builds context automatically.
+
+# Bad
+Project files are read and context is built automatically.
+```
+
+### Use Neutral Pronouns for Cline
+
+Refer to Cline as "it" not "he". Cline is software, not a person.
+
+```markdown
+# Good
+When Cline encounters an error, it suggests fixes.
+
+# Bad
+When Cline encounters an error, he suggests fixes.
+```
+
+## File Format
+
+All documentation uses MDX format with YAML frontmatter:
+
+```yaml
+---
+title: "Full Page Title"
+sidebarTitle: "Shorter Nav Title"  # optional
+description: "One sentence for SEO"  # optional but recommended
+---
+```
+
+### Adding New Pages
+
+After creating a new `.mdx` file, add it to `docs/docs.json` in the appropriate navigation group:
+
+```json
+{
+  "group": "Features",
+  "pages": [
+    "features/existing-page",
+    "features/your-new-page"
+  ]
+}
+```
+
+## Mintlify Components
+
+Use these components appropriately throughout your docs.
+
+### Frame
+
+Wrap all images and videos:
+
+```jsx
+<Frame>
+  <img 
+    src="https://storage.googleapis.com/cline_public_images/docs/assets/filename.png" 
+    alt="Descriptive alt text" 
+  />
+</Frame>
+```
+
+### Callouts
+
+Use sparingly and purposefully:
+
+```jsx
+<Tip>Helpful suggestions that improve the experience.</Tip>
+<Note>Important information the reader needs to know.</Note>
+<Warning>Something that could cause problems if ignored.</Warning>
+```
+
+### Steps
+
+For sequential procedures:
+
+```jsx
+<Steps>
+  <Step title="Install the Extension">
+    Search for "Cline" in the VS Code marketplace.
+  </Step>
+  <Step title="Configure Your Model">
+    Open settings and add your API key.
+  </Step>
+</Steps>
+```
+
+### Cards
+
+For navigation and feature overviews:
+
+```jsx
+<CardGroup cols={2}>
+  <Card title="Getting Started" icon="rocket" href="/getting-started/installing-cline">
+    Install Cline and set up your first project.
+  </Card>
+  <Card title="Features" icon="wand-magic-sparkles" href="/core-workflows/plan-and-act">
+    Explore what Cline can do.
+  </Card>
+</CardGroup>
+```
+
+## Style Rules
+
+Quick reference for consistent documentation:
+
+| Do | Don't |
+|---|---|
+| Use "use" | Use "utilize" |
+| Keep sentences under 25 words | Write run-on sentences |
+| Use bullet points for lists | Write walls of text |
+| Show where things are in the UI | Assume users can find features |
+| Cross-link related docs | Leave readers stranded |
+| Use code blocks with language tags | Use inline code for long snippets |
+
+### Avoid These Patterns
+
+- Em dashes and emojis
+- Starting with "This document explains..."
+- The **Bold Text**: description pattern
+- Explaining obvious things
+- Passive voice
+
+## Previewing Changes
+
+Run the docs locally to preview your changes:
+
+```bash
+cd docs
+npm install  # first time only
+npm run dev
+```
+
+Open `http://localhost:3000` to see your changes in real time.
+
+## Related Resources
+
+<CardGroup cols={2}>
+  <Card title="Documentation Templates" icon="file-lines" href="/contributing/doc-templates">
+    Templates for different documentation types.
+  </Card>
+  <Card title="Workflows" icon="diagram-project" href="/customization/workflows">
+    Learn about Cline's workflow system.
+  </Card>
+</CardGroup>

docs/core-features/model-selection-guide.mdx

@@ -1,6 +1,6 @@
 ---
 title: "Model Selection Guide"
-description: "Last updated: August 20, 2025."
+description: "Choose the right AI model for your workflow based on reliability, speed, cost, and context window size."
 ---
 
 New models drop constantly, so this guide focuses on what's working well with Cline right now. We'll keep it updated as the landscape shifts.
@@ -59,12 +59,17 @@ Choose your preferred AI provider from the dropdown menu.
 | **Cline** | Easiest setup | No API keys needed, access to multiple models including stealth models |
 | **OpenRouter** | Value seekers | Multiple models, competitive pricing |
 | **Anthropic** | Reliability | Claude models, most dependable tool usage |
-| **OpenAI** | Latest tech | GPT models |
-| **Google Gemini** | Large context | Google's AI models |
+| **OpenAI** | Latest tech | GPT-5, o3, o4-mini models |
+| **OpenAI Codex** | ChatGPT subscribers | Use your ChatGPT subscription — no API key needed |
+| **Google Gemini** | Large context | Gemini 3/2.5 with up to 2M context |
+| **DeepSeek** | Budget reasoning | V3.2, R1 models at low cost |
+| **Alibaba Qwen** | Open source coding | Qwen3 Coder with 1M context |
+| **Moonshot** | Agentic coding | Kimi K2.5 with 262K context |
+| **Cerebras** | Speed | Up to 2,600 tokens/sec |
 | **AWS Bedrock** | Enterprise | Advanced features |
 | **Ollama** | Privacy | Run models locally |
 
-See the [full provider list](/provider-config) for more options including Cerebras, Vertex AI, Azure, and more.
+See the [full provider list](/getting-started/authorizing-with-cline) for all 30+ supported providers including xAI Grok, Mistral, Groq, Fireworks, Together, Baseten, SambaNova, Nebius, Hugging Face, and more.
 
 <Info>
 **Recommended for beginners:** Start with **Cline** as your provider - no API key management needed, instant access to multiple models, and occasional free inferencing through partner providers.
@@ -81,6 +86,19 @@ The next step depends on which provider you selected.
 - You'll be redirected to [app.cline.bot](https://app.cline.bot) to authenticate
 - After signing in, return to your IDE
 
+<Note>
+  For detailed information about the Cline authentication flow, OAuth tokens, and troubleshooting, see [Authorizing with Cline](/getting-started/authorizing-with-cline).
+</Note>
+
+#### If you selected **OpenAI Codex** as your provider:
+
+- **No API key needed!** If you have a ChatGPT subscription (Plus, Pro, or Team), you can use it directly in Cline
+- Click **"Sign in with OpenAI"** to authenticate via your browser
+- Once authorized, all models available on your OpenAI plan will appear automatically
+- Usage is governed by your ChatGPT subscription — no separate API billing
+
+See the full [OpenAI Codex setup guide](/provider-config/openai-codex) for details.
+
 #### If you selected any other provider:
 
 You'll need to get an API key from your chosen provider:
@@ -90,7 +108,7 @@ You'll need to get an API key from your chosen provider:
    - **OpenRouter**: [openrouter.ai/keys](https://openrouter.ai/keys)
    - **OpenAI**: [platform.openai.com/api-keys](https://platform.openai.com/api-keys)
    - **Google**: [aistudio.google.com/apikey](https://aistudio.google.com/apikey)
-   - **Others**: See [Provider Setup Guide](/provider-config)
+   - **Others**: See [Provider Setup Guide](/getting-started/authorizing-with-cline)
 
 2. **Generate a new API key** on the provider's website
 
@@ -168,8 +186,7 @@ Selecting the right model involves balancing several factors. Use this framework
 
 ## Model Comparison Resources
 
-For detailed model comparisons, pricing, and performance metrics, see:
-- [**Model Comparison & Pricing**](/model-config/model-comparison) - Complete pricing tables and performance benchmarks
+For detailed model comparisons and performance metrics, see:
 - [**Context Window Guide**](/model-config/context-windows) - Understanding and optimizing context usage
 
 ## Open Source vs Closed Source
@@ -195,8 +212,9 @@ For detailed model comparisons, pricing, and performance metrics, see:
 | Huge context windows | Gemini 2.5 Pro or Claude Sonnet 4.5 |
 | Open source | Qwen3 Coder, Z AI GLM 4.5, or Kimi K2 |
 | Latest tech | GPT-5 |
+| To use your ChatGPT subscription | [OpenAI Codex](/provider-config/openai-codex) — sign in with your OpenAI account, no API key needed |
 | Speed | Qwen3 Coder on Cerebras (fastest available) |
 
 ## What Others Are Using
 
-Check [OpenRouter's Cline usage stats](https://openrouter.ai/apps?url=https%3A%2F%2Fcline.bot%2F) to see real usage patterns from the community.
+Check [Vercel's leaderboard](https://vercel.com/ai-gateway/leaderboards) to see real usage patterns from the community.

docs/core-workflows/checkpoints.mdx

@@ -0,0 +1,95 @@
+---
+title: "Checkpoints"
+sidebarTitle: "Checkpoints"
+description: "Roll back code changes while keeping your conversation. Experiment freely."
+---
+
+Checkpoints let you undo code changes without losing your conversation. Every time Cline modifies a file or runs a command, it saves a snapshot of your project files. You can restore to any checkpoint, keeping the context you've built while reverting the code.
+
+This changes how you work with Cline. Instead of carefully reviewing every change before approving, you can let Cline move fast and roll back if something goes wrong. The cost of a mistake drops to nearly zero.
+
+<Tip>
+Checkpoints are enabled by default. See [Enable or Disable Checkpoints](#enable-or-disable-checkpoints) if you need to turn them off.
+</Tip>
+
+## How It Works
+
+Cline maintains a shadow Git repository separate from your project's actual Git history. After each tool use (file edits, commands, etc.), Cline commits the current state of your files to this shadow repo. Your main Git repository stays untouched.
+
+This means:
+
+- Your Git history remains clean and under your control
+- Checkpoints capture everything, including files not tracked by Git
+- You can restore to any point in a task without affecting commits you've made
+- Checkpoints persist across editor sessions
+
+Each checkpoint captures the complete file state at that moment. If Cline edits three files in sequence, you get three checkpoints and can restore to any of them independently.
+
+## Enable or Disable Checkpoints
+
+Checkpoints are enabled by default. To toggle them:
+
+1. Open Cline settings (gear icon in the Cline sidebar)
+2. Scroll to the "Feature Settings" section
+3. Toggle "Enable Checkpoints"
+
+<Note>
+For very large repositories, checkpoints may use significant storage and slow down Cline as it commits file snapshots after each tool use. Consider disabling them if you notice performance issues.
+</Note>
+
+## Viewing and Comparing Changes
+
+After each tool use, a checkpoint indicator appears in your conversation. Look for a bookmark icon labeled "Checkpoint" with a dotted line connecting to **Compare** and **Restore** buttons.
+
+Click **Compare** to open a diff view showing exactly what changed at that checkpoint. This opens in your editor's diff viewer, letting you see additions, deletions, and modifications across all affected files.
+
+This is useful when Cline makes changes you want to understand before deciding whether to keep them. You can review the diff, then either continue or restore to undo.
+
+## Restoring Checkpoints
+
+Click **Restore** next to any step to open the restore menu. You have three options:
+
+| Option | What It Does | When to Use It |
+|--------|--------------|----------------|
+| **Restore Files** | Reverts your project's files to the snapshot at this checkpoint | Undoing code changes while keeping the conversation |
+| **Restore Task Only** | Deletes messages after this point, does not affect files | Trying a different prompt while keeping current code |
+| **Restore Files & Task** | Reverts files and deletes messages after this point | Starting over completely from a known good state |
+
+The right choice depends on what went wrong:
+
+- If the conversation is productive but the code changes broke something, use **Restore Files**. Cline keeps all the context you've discussed and can try a different implementation.
+
+- If Cline's code changes are good but the conversation went off track, use **Restore Task Only**. You keep the files and can guide the conversation differently.
+
+- If you want to start over from a clean slate, use **Restore Files & Task**. This resets both your files and the conversation to that checkpoint.
+
+## When to Use Checkpoints
+
+| Scenario | Recommended Action |
+|----------|-------------------|
+| Cline refactored code and broke something | Restore Files, ask for a different approach |
+| Experimenting with multiple solutions | Compare each checkpoint, restore to the best one |
+| Cline misunderstood your intent | Restore Files & Task, rephrase your request |
+| Want to try a different prompt | Restore Task Only, keep the files, resubmit |
+| Reviewing changes before committing to Git | Use Compare to inspect, then commit manually |
+| Testing risky changes | Let Cline proceed, restore if it fails |
+
+## Working with Auto-Approve
+
+Checkpoints make [auto-approve](/features/auto-approve) practical. Without checkpoints, auto-approve feels risky because Cline can make many changes before you notice a problem. With checkpoints, you can let Cline work autonomously and roll back if needed.
+
+A typical workflow:
+
+1. Enable auto-approve for file edits and commands
+2. Let Cline work through your task quickly
+3. Review the final result
+4. If something is wrong, restore to the last good checkpoint
+5. Give Cline more specific guidance
+
+This approach is faster than reviewing every change individually, and checkpoints provide the safety net.
+
+## Checkpoints and Message Editing
+
+The message editing feature integrates with checkpoints. When you edit a previous message and select "Restore All," Cline restores your files to the checkpoint at that point before resubmitting your edited message.
+
+This lets you fix a poorly worded prompt and undo all the changes that resulted from it in one action.

docs/core-workflows/plan-and-act.mdx

@@ -0,0 +1,120 @@
+---
+title: "Plan & Act Mode"
+sidebarTitle: "Plan & Act Mode"
+description: "Think first, then build. Cline's dual-mode system for structured development."
+---
+
+Plan & Act modes separate thinking from doing. Plan mode lets you explore and strategize without changing files. Act mode executes against your plan.
+
+<Tip>
+	**New to Plan & Act?** Watch [Plan & Act Deep Dive](https://youtu.be/b7o6URFPp64) to see it in action.
+</Tip>
+
+## Plan Mode
+
+Plan mode is where you and Cline figure out what you're building and how. In this mode, Cline can read your codebase, run searches, and discuss strategy, but cannot modify any files or execute commands.
+
+This constraint is intentional. It keeps the conversation focused on understanding and planning, without the distraction of implementation details. You can explore freely, ask questions, and iterate on the approach before committing to changes.
+
+Use Plan mode to:
+
+- Explore unfamiliar codebases before making changes
+- Discuss architecture decisions and tradeoffs
+- Identify edge cases and potential issues upfront
+- Create a clear implementation strategy
+- Review code and understand complex workflows
+
+## Act Mode
+
+Once you have a plan, switch to Act mode. Cline retains the full context from your planning session and can now modify files, run commands, and execute your strategy.
+
+The conversation history carries over when you switch modes. Cline remembers everything you discussed in Plan mode, so you don't need to repeat yourself. This makes the transition seamless.
+
+<Note>
+	While you can start directly in Act mode, planning first is highly recommended. The planning phase intentionally builds context that Cline needs to implement changes effectively. Without it, Cline may lack the understanding required to make the right decisions.
+</Note>
+
+## Typical Workflow
+
+1. Start in Plan mode and describe what you want to build
+2. Let Cline explore relevant files and understand the codebase
+3. Discuss the approach, considering edge cases and potential issues
+4. When confident in the plan, switch to Act mode
+5. Cline implements the solution based on your planning session
+
+For complex projects, you may cycle between modes multiple times. Return to Plan mode when you hit unexpected complexity or need to rethink the approach, then switch back to Act mode to continue implementation.
+
+## When to Use Each Mode
+
+| Scenario | Recommended Mode |
+|----------|-----------------|
+| Starting new features where the approach isn't obvious | Plan |
+| Debugging tricky issues where you're unsure what's wrong | Plan |
+| Making architectural decisions affecting multiple files | Plan |
+| Understanding complex workflows before modifying them | Plan |
+| Code review and security analysis | Plan |
+| Learning a new codebase | Plan |
+| Implementing a solution you've already planned | Act |
+| Making routine changes with a clear approach | Act |
+| Following established patterns in the codebase | Act |
+| Running tests and making adjustments | Act |
+| Quick fixes where the solution is obvious | Act |
+
+## Using Different Models for Each Mode
+
+You can configure separate models for Plan and Act modes. This is useful when you want to use a stronger reasoning model for planning and a faster model for implementation.
+
+To enable this:
+
+1. Open Cline Settings
+2. Enable "Use different models for Plan and Act"
+3. Select your preferred model for each mode
+
+When enabled, switching between Plan and Act mode automatically switches to the configured model for that mode. Your model selection is preserved when you switch back.
+
+**Example configurations:**
+
+| Use Case | Plan Mode | Act Mode |
+|----------|-----------|----------|
+| Cost optimization | GLM 4.6 | Grok Code Fast |
+| Maximum quality | Claude Opus | Claude Sonnet |
+| Speed-focused | Gemini 3 Flash | Cerebras |
+
+## Using `/deep-planning`
+
+For complex tasks that need thorough analysis, use the `/deep-planning` slash command. This triggers an extended planning session where Cline:
+
+1. Explores the codebase systematically
+2. Identifies all affected files and dependencies
+3. Creates a detailed implementation plan
+4. Asks clarifying questions before proceeding
+
+The deep planning prompt is optimized for each model family, so it adapts to the strengths of whatever model you're using. See the [Deep Planning docs](/features/deep-planning) for more details.
+
+## Choosing the Right Approach by Task Size
+
+### Small tasks: Act mode only
+
+For quick fixes like typos, simple bug fixes, or following established patterns, start directly in Act mode. Planning adds overhead when the solution is obvious.
+
+**Examples:** Fix a typo, add a missing import, update a config value, rename a variable.
+
+### Medium tasks: Plan → Act
+
+For most development work, start in Plan mode to understand the scope and approach, then switch to Act mode to implement. This is the sweet spot for features that touch a few files and have some complexity.
+
+**Examples:** Add a new API endpoint, implement a UI component, fix a bug that requires investigation, refactor a single module.
+
+### Large tasks: Use `/deep-planning`
+
+For complex features that span multiple files, require architectural decisions, or will take multiple sessions to complete, use the `/deep-planning` slash command. This creates a detailed implementation plan that Cline can reference throughout the work.
+
+**Examples:** Add a new feature across frontend and backend, major refactoring across the codebase, implementing a new system or integration, multi-step migrations.
+
+## Tips
+
+- Have Cline write a markdown file summarizing the plan for future reference
+- Use [file mentions](/core-workflows/working-with-files) to point Cline at relevant files during planning
+- Switch back to Plan mode when encountering unexpected complexity rather than pushing through
+- Enable [Checkpoints](/core-workflows/checkpoints) before Act mode so you can roll back if needed
+- For large tasks, ask Cline to create a todo list during planning that you can track in Act mode